From 9e3c08db40b8916968b9f30096c7be3f00ce9647 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 21 Apr 2024 13:44:51 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- third_party/rust/ash/.cargo-checksum.json | 1 + third_party/rust/ash/Cargo.toml | 53 + third_party/rust/ash/LICENSE-APACHE | 67 + third_party/rust/ash/LICENSE-MIT | 25 + third_party/rust/ash/README.md | 289 + third_party/rust/ash/build.rs | 24 + third_party/rust/ash/src/device.rs | 2707 + third_party/rust/ash/src/entry.rs | 402 + .../rust/ash/src/extensions/experimental/amd.rs | 722 + .../rust/ash/src/extensions/experimental/mod.rs | 1 + .../ash/src/extensions/ext/acquire_drm_display.rs | 55 + .../src/extensions/ext/buffer_device_address.rs | 44 + .../src/extensions/ext/calibrated_timestamps.rs | 72 + .../rust/ash/src/extensions/ext/debug_marker.rs | 71 + .../rust/ash/src/extensions/ext/debug_report.rs | 68 + .../rust/ash/src/extensions/ext/debug_utils.rs | 173 + .../ash/src/extensions/ext/descriptor_buffer.rs | 211 + .../src/extensions/ext/extended_dynamic_state.rs | 196 + .../src/extensions/ext/extended_dynamic_state2.rs | 85 + .../src/extensions/ext/extended_dynamic_state3.rs | 409 + .../src/extensions/ext/full_screen_exclusive.rs | 86 + .../ash/src/extensions/ext/headless_surface.rs | 55 + .../extensions/ext/image_compression_control.rs | 47 + .../extensions/ext/image_drm_format_modifier.rs | 48 + .../rust/ash/src/extensions/ext/mesh_shader.rs | 94 + .../rust/ash/src/extensions/ext/metal_surface.rs | 54 + third_party/rust/ash/src/extensions/ext/mod.rs | 45 + .../ash/src/extensions/ext/physical_device_drm.rs | 26 + .../rust/ash/src/extensions/ext/private_data.rs | 105 + .../ash/src/extensions/ext/sample_locations.rs | 54 + .../rust/ash/src/extensions/ext/tooling_info.rs | 40 + .../src/extensions/khr/acceleration_structure.rs | 322 + .../rust/ash/src/extensions/khr/android_surface.rs | 54 + .../src/extensions/khr/buffer_device_address.rs | 62 + .../rust/ash/src/extensions/khr/copy_commands2.rs | 84 + .../ash/src/extensions/khr/create_render_pass2.rs | 90 + .../src/extensions/khr/deferred_host_operations.rs | 93 + .../rust/ash/src/extensions/khr/device_group.rs | 169 + .../src/extensions/khr/device_group_creation.rs | 66 + third_party/rust/ash/src/extensions/khr/display.rs | 143 + .../ash/src/extensions/khr/display_swapchain.rs | 57 + .../ash/src/extensions/khr/draw_indirect_count.rs | 74 + .../ash/src/extensions/khr/dynamic_rendering.rs | 44 + .../ash/src/extensions/khr/external_fence_fd.rs | 49 + .../ash/src/extensions/khr/external_fence_win32.rs | 58 + .../ash/src/extensions/khr/external_memory_fd.rs | 60 + .../src/extensions/khr/external_memory_win32.rs | 66 + .../src/extensions/khr/external_semaphore_fd.rs | 52 + .../src/extensions/khr/external_semaphore_win32.rs | 58 + .../src/extensions/khr/get_memory_requirements2.rs | 92 + .../khr/get_physical_device_properties2.rs | 167 + .../extensions/khr/get_surface_capabilities2.rs | 84 + .../rust/ash/src/extensions/khr/maintenance1.rs | 45 + .../rust/ash/src/extensions/khr/maintenance3.rs | 45 + .../rust/ash/src/extensions/khr/maintenance4.rs | 91 + third_party/rust/ash/src/extensions/khr/mod.rs | 75 + .../khr/pipeline_executable_properties.rs | 84 + .../rust/ash/src/extensions/khr/present_wait.rs | 47 + .../rust/ash/src/extensions/khr/push_descriptor.rs | 68 + .../src/extensions/khr/ray_tracing_maintenance1.rs | 42 + .../ash/src/extensions/khr/ray_tracing_pipeline.rs | 194 + third_party/rust/ash/src/extensions/khr/surface.rs | 110 + .../rust/ash/src/extensions/khr/swapchain.rs | 211 + .../ash/src/extensions/khr/synchronization2.rs | 101 + .../ash/src/extensions/khr/timeline_semaphore.rs | 60 + .../rust/ash/src/extensions/khr/wayland_surface.rs | 71 + .../rust/ash/src/extensions/khr/win32_surface.rs | 69 + .../rust/ash/src/extensions/khr/xcb_surface.rs | 73 + .../rust/ash/src/extensions/khr/xlib_surface.rs | 73 + third_party/rust/ash/src/extensions/mod.rs | 6 + .../rust/ash/src/extensions/mvk/ios_surface.rs | 54 + .../rust/ash/src/extensions/mvk/macos_surface.rs | 54 + third_party/rust/ash/src/extensions/mvk/mod.rs | 5 + third_party/rust/ash/src/extensions/nn/mod.rs | 3 + .../rust/ash/src/extensions/nn/vi_surface.rs | 54 + .../src/extensions/nv/coverage_reduction_mode.rs | 70 + .../extensions/nv/device_diagnostic_checkpoints.rs | 63 + .../rust/ash/src/extensions/nv/mesh_shader.rs | 81 + third_party/rust/ash/src/extensions/nv/mod.rs | 9 + .../rust/ash/src/extensions/nv/ray_tracing.rs | 271 + third_party/rust/ash/src/instance.rs | 535 + third_party/rust/ash/src/lib.rs | 197 + third_party/rust/ash/src/prelude.rs | 122 + third_party/rust/ash/src/util.rs | 139 + third_party/rust/ash/src/vk.rs | 52 + third_party/rust/ash/src/vk/aliases.rs | 251 + third_party/rust/ash/src/vk/bitflags.rs | 1643 + third_party/rust/ash/src/vk/const_debugs.rs | 7167 ++ third_party/rust/ash/src/vk/constants.rs | 27 + third_party/rust/ash/src/vk/definitions.rs | 73178 +++++++++++++++++++ third_party/rust/ash/src/vk/enums.rs | 2917 + third_party/rust/ash/src/vk/extensions.rs | 25322 +++++++ third_party/rust/ash/src/vk/feature_extensions.rs | 451 + third_party/rust/ash/src/vk/features.rs | 5353 ++ third_party/rust/ash/src/vk/macros.rs | 162 + third_party/rust/ash/src/vk/native.rs | 8998 +++ third_party/rust/ash/src/vk/platform_types.rs | 41 + third_party/rust/ash/src/vk/prelude.rs | 61 + third_party/rust/ash/tests/constant_size_arrays.rs | 33 + third_party/rust/ash/tests/display.rs | 17 + 100 files changed, 137068 insertions(+) create mode 100644 third_party/rust/ash/.cargo-checksum.json create mode 100644 third_party/rust/ash/Cargo.toml create mode 100644 third_party/rust/ash/LICENSE-APACHE create mode 100644 third_party/rust/ash/LICENSE-MIT create mode 100644 third_party/rust/ash/README.md create mode 100644 third_party/rust/ash/build.rs create mode 100644 third_party/rust/ash/src/device.rs create mode 100644 third_party/rust/ash/src/entry.rs create mode 100644 third_party/rust/ash/src/extensions/experimental/amd.rs create mode 100644 third_party/rust/ash/src/extensions/experimental/mod.rs create mode 100644 third_party/rust/ash/src/extensions/ext/acquire_drm_display.rs create mode 100644 third_party/rust/ash/src/extensions/ext/buffer_device_address.rs create mode 100644 third_party/rust/ash/src/extensions/ext/calibrated_timestamps.rs create mode 100755 third_party/rust/ash/src/extensions/ext/debug_marker.rs create mode 100755 third_party/rust/ash/src/extensions/ext/debug_report.rs create mode 100755 third_party/rust/ash/src/extensions/ext/debug_utils.rs create mode 100644 third_party/rust/ash/src/extensions/ext/descriptor_buffer.rs create mode 100644 third_party/rust/ash/src/extensions/ext/extended_dynamic_state.rs create mode 100644 third_party/rust/ash/src/extensions/ext/extended_dynamic_state2.rs create mode 100644 third_party/rust/ash/src/extensions/ext/extended_dynamic_state3.rs create mode 100644 third_party/rust/ash/src/extensions/ext/full_screen_exclusive.rs create mode 100644 third_party/rust/ash/src/extensions/ext/headless_surface.rs create mode 100644 third_party/rust/ash/src/extensions/ext/image_compression_control.rs create mode 100644 third_party/rust/ash/src/extensions/ext/image_drm_format_modifier.rs create mode 100644 third_party/rust/ash/src/extensions/ext/mesh_shader.rs create mode 100644 third_party/rust/ash/src/extensions/ext/metal_surface.rs create mode 100644 third_party/rust/ash/src/extensions/ext/mod.rs create mode 100644 third_party/rust/ash/src/extensions/ext/physical_device_drm.rs create mode 100644 third_party/rust/ash/src/extensions/ext/private_data.rs create mode 100644 third_party/rust/ash/src/extensions/ext/sample_locations.rs create mode 100644 third_party/rust/ash/src/extensions/ext/tooling_info.rs create mode 100644 third_party/rust/ash/src/extensions/khr/acceleration_structure.rs create mode 100755 third_party/rust/ash/src/extensions/khr/android_surface.rs create mode 100644 third_party/rust/ash/src/extensions/khr/buffer_device_address.rs create mode 100644 third_party/rust/ash/src/extensions/khr/copy_commands2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/create_render_pass2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/deferred_host_operations.rs create mode 100644 third_party/rust/ash/src/extensions/khr/device_group.rs create mode 100644 third_party/rust/ash/src/extensions/khr/device_group_creation.rs create mode 100755 third_party/rust/ash/src/extensions/khr/display.rs create mode 100755 third_party/rust/ash/src/extensions/khr/display_swapchain.rs create mode 100644 third_party/rust/ash/src/extensions/khr/draw_indirect_count.rs create mode 100644 third_party/rust/ash/src/extensions/khr/dynamic_rendering.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_fence_fd.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_fence_win32.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_memory_fd.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_memory_win32.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_semaphore_fd.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_semaphore_win32.rs create mode 100644 third_party/rust/ash/src/extensions/khr/get_memory_requirements2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/get_physical_device_properties2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/get_surface_capabilities2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/maintenance1.rs create mode 100644 third_party/rust/ash/src/extensions/khr/maintenance3.rs create mode 100644 third_party/rust/ash/src/extensions/khr/maintenance4.rs create mode 100644 third_party/rust/ash/src/extensions/khr/mod.rs create mode 100644 third_party/rust/ash/src/extensions/khr/pipeline_executable_properties.rs create mode 100644 third_party/rust/ash/src/extensions/khr/present_wait.rs create mode 100644 third_party/rust/ash/src/extensions/khr/push_descriptor.rs create mode 100644 third_party/rust/ash/src/extensions/khr/ray_tracing_maintenance1.rs create mode 100644 third_party/rust/ash/src/extensions/khr/ray_tracing_pipeline.rs create mode 100755 third_party/rust/ash/src/extensions/khr/surface.rs create mode 100755 third_party/rust/ash/src/extensions/khr/swapchain.rs create mode 100644 third_party/rust/ash/src/extensions/khr/synchronization2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/timeline_semaphore.rs create mode 100755 third_party/rust/ash/src/extensions/khr/wayland_surface.rs create mode 100755 third_party/rust/ash/src/extensions/khr/win32_surface.rs create mode 100755 third_party/rust/ash/src/extensions/khr/xcb_surface.rs create mode 100755 third_party/rust/ash/src/extensions/khr/xlib_surface.rs create mode 100644 third_party/rust/ash/src/extensions/mod.rs create mode 100755 third_party/rust/ash/src/extensions/mvk/ios_surface.rs create mode 100755 third_party/rust/ash/src/extensions/mvk/macos_surface.rs create mode 100644 third_party/rust/ash/src/extensions/mvk/mod.rs create mode 100644 third_party/rust/ash/src/extensions/nn/mod.rs create mode 100644 third_party/rust/ash/src/extensions/nn/vi_surface.rs create mode 100644 third_party/rust/ash/src/extensions/nv/coverage_reduction_mode.rs create mode 100644 third_party/rust/ash/src/extensions/nv/device_diagnostic_checkpoints.rs create mode 100755 third_party/rust/ash/src/extensions/nv/mesh_shader.rs create mode 100644 third_party/rust/ash/src/extensions/nv/mod.rs create mode 100755 third_party/rust/ash/src/extensions/nv/ray_tracing.rs create mode 100644 third_party/rust/ash/src/instance.rs create mode 100644 third_party/rust/ash/src/lib.rs create mode 100644 third_party/rust/ash/src/prelude.rs create mode 100644 third_party/rust/ash/src/util.rs create mode 100644 third_party/rust/ash/src/vk.rs create mode 100644 third_party/rust/ash/src/vk/aliases.rs create mode 100644 third_party/rust/ash/src/vk/bitflags.rs create mode 100644 third_party/rust/ash/src/vk/const_debugs.rs create mode 100644 third_party/rust/ash/src/vk/constants.rs create mode 100644 third_party/rust/ash/src/vk/definitions.rs create mode 100644 third_party/rust/ash/src/vk/enums.rs create mode 100644 third_party/rust/ash/src/vk/extensions.rs create mode 100644 third_party/rust/ash/src/vk/feature_extensions.rs create mode 100644 third_party/rust/ash/src/vk/features.rs create mode 100644 third_party/rust/ash/src/vk/macros.rs create mode 100644 third_party/rust/ash/src/vk/native.rs create mode 100644 third_party/rust/ash/src/vk/platform_types.rs create mode 100644 third_party/rust/ash/src/vk/prelude.rs create mode 100644 third_party/rust/ash/tests/constant_size_arrays.rs create mode 100644 third_party/rust/ash/tests/display.rs (limited to 'third_party/rust/ash') diff --git a/third_party/rust/ash/.cargo-checksum.json b/third_party/rust/ash/.cargo-checksum.json new file mode 100644 index 0000000000..ecaa49b60b --- /dev/null +++ b/third_party/rust/ash/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"f5ba364e2195938f21eec077ff01ae3977589f75e0dd9315507058d87f229cb3","LICENSE-APACHE":"0e8a410375e1ee5c75c6198b08b534fec6e5edef766cf971bab4a404542636ab","LICENSE-MIT":"c733ccf8ab25df175a63d9d844677b98e3a5ab8f8de1c1616087e6868a7f948e","README.md":"486092d206c93d24e2108dd0df17571a19c0f029306102d0970d0791364d6497","build.rs":"616f1c2f1a0dd883d57690b767691750c1762fb01ab4aeb662825ceecf869e7b","src/device.rs":"3821bad3d35753a9dcb95dfe9c59ae0f70ce55495ec05239fb523dbb1524e232","src/entry.rs":"7e0e9a0a4a71515d453761dc2c8839d5ba3ce4c9a038433279749ae4b3e795d5","src/extensions/experimental/amd.rs":"e89f7cf4d4b9335ae74391fddc85d03106b121b6d964ea8fad35593e9918f4e6","src/extensions/experimental/mod.rs":"41a5366e1c8bd0e1fa47e9cf6fddc8111ed0a6946813be4eefca81da969d1ee9","src/extensions/ext/acquire_drm_display.rs":"095af0b7336a2cc03e0f5584d994db8df1ad14f52360456407725013d33298ad","src/extensions/ext/buffer_device_address.rs":"124033d6e8f3251cf0d44e7d0d51d9ef28770d6c7d2fe283ffa98a32ba4ead55","src/extensions/ext/calibrated_timestamps.rs":"ba0ac6e38e7feb62b482ed9371c11447669d0d88b18bfc5e59ea75d5ed78691c","src/extensions/ext/debug_marker.rs":"33044f1f3f46280eb3f2564c9c8d66f5a470dbac51baeff34d2997f2c6a0fb94","src/extensions/ext/debug_report.rs":"405b179a8b155adbafabfaf9d38a5fb84e78c78dced79e72d64fb507520a85b1","src/extensions/ext/debug_utils.rs":"a496af59111353313013799b8862eacf343cf826c9901212c7838ec2fab40fe5","src/extensions/ext/descriptor_buffer.rs":"ae9c2ce265ada99b2ff99d6c2fe55f4842b9213cfaa2010ea7cf1a738e01c15d","src/extensions/ext/extended_dynamic_state.rs":"feeb16916cf2288713df1dd79545c9f484e3b115a2e93aa00e621b59b92085ff","src/extensions/ext/extended_dynamic_state2.rs":"ac30857e100ef00578ebcdd6d9d0136ebad95454965780836f15b42a88c00497","src/extensions/ext/extended_dynamic_state3.rs":"4e3b95846dff78cb9a467641324075741c2cb71d53233ec52b0727e066faae4d","src/extensions/ext/full_screen_exclusive.rs":"9572aa10253ff7c6d0f79b4ce92114ee48499d260043860db9ea268faf95756b","src/extensions/ext/headless_surface.rs":"dc0540ca8bb9be99975d8f432a062e1dcac53bb43dcd81a0450673fe9a3798cb","src/extensions/ext/image_compression_control.rs":"6f704c54ab6965058d0f9aef8eef9b6d7d713c419270494f8a7f1f560ee827a9","src/extensions/ext/image_drm_format_modifier.rs":"452d9833283dd2913de676747cc54b27df070915bfd8b31184ded4d9f299656d","src/extensions/ext/mesh_shader.rs":"c4c30eb1a8de3db5ad11b4f4f77c41c8981634e47495aee58ac07a6297e8344c","src/extensions/ext/metal_surface.rs":"3175d1d51e49e00cbdeabdc050932d547bffc4b0842a7e30049141ee99dda107","src/extensions/ext/mod.rs":"6daf2b78f4e6bd801b45cdf4213eb0acd7e313b5786c98e218e85ac2baf04676","src/extensions/ext/physical_device_drm.rs":"450fd7e6a136e5e0079836ab65f89a7a0ed90af5469abebd99afd2b14d155c55","src/extensions/ext/private_data.rs":"a92e37ea025d2a8106a2034403de4bfdc954b411a8c1c4f29d955d81fcfbd4a0","src/extensions/ext/sample_locations.rs":"fc664942394362a00eeb1086b63e4ab84df8884bb299db05ef6a14f98434bd1c","src/extensions/ext/tooling_info.rs":"8a4f6570d15e2a1cbea9a8fa8e70cf358aa76336e108bade9c46de25b65bf5cb","src/extensions/khr/acceleration_structure.rs":"935628eee2aa943286a2fe387dcd0655c8a539e52dcbce7769d0fd71b3af64f7","src/extensions/khr/android_surface.rs":"8183a1ba413b894287014b934df3888cb6d53b8f95bbe3f299b91fd481cdd2eb","src/extensions/khr/buffer_device_address.rs":"6ffb9bad123139cff26c77ea5a7a4556bb24a6d3daa47fc3378d67c016157098","src/extensions/khr/copy_commands2.rs":"58717fd89144de4fded43601ebb8997b14a67eb0d18b85f1ab739457cbaef1d0","src/extensions/khr/create_render_pass2.rs":"c4c15abbe9dff9778c2ecd25556ab88bd642facca75d7c69e4023ec157fce12c","src/extensions/khr/deferred_host_operations.rs":"facf3c32ea9b5093a0b8f5c8ca3e89d5517a6e39f5e781deffc91f3170c77443","src/extensions/khr/device_group.rs":"5a54fba7b9f1cd25aa2281eabeca226de5ba76bd1433adb76d4e5d650a7862b5","src/extensions/khr/device_group_creation.rs":"368e5139ade893b71e1a333cab54605b76f51656bb8e4936c492f80069616d84","src/extensions/khr/display.rs":"c8241e5d8d39b74ecc4766faba27efca5cbd31382d8d40ac2f2f4e54f1f8d88d","src/extensions/khr/display_swapchain.rs":"9bbf1d47989a1550a3515c6d98367aa0df67b43ea102be329a658e0f458ae1d9","src/extensions/khr/draw_indirect_count.rs":"14acfbdb21a96db1bd0bad467af341ee327d5a4a78b2727aa5c5707560b157f8","src/extensions/khr/dynamic_rendering.rs":"bc363c863ef269bf905de0a3e7414fc5f37af7da88412086b31f1065d0a1178f","src/extensions/khr/external_fence_fd.rs":"0a89e00c9560e6fc4b63d6295260bb5db79bb595232217ce1723ba0a4aa0af38","src/extensions/khr/external_fence_win32.rs":"a357d7dcea8e50f3b26f5bb2fbe0bcbdc1b94aa4b6bbc784570715bcb06a23a9","src/extensions/khr/external_memory_fd.rs":"624d0bcf61e16ee9e284d71354fc18a8141ec14b2fd8e1d5c1ed0547f0bd2fcf","src/extensions/khr/external_memory_win32.rs":"d731d4e531e55a7ba53bdec2045167cf494ca7b54267edc205be675790a579ef","src/extensions/khr/external_semaphore_fd.rs":"8254d0e50e26761e10b523e4d45c6128d304926880a02144724145fd4d412898","src/extensions/khr/external_semaphore_win32.rs":"2fcc7fb4ba50f94e60d1faeefdb0e4f6940120766143c9ce7257d7c0356b68af","src/extensions/khr/get_memory_requirements2.rs":"56edbc8cb1a335071518fdf52d1f549ab31292551cd5ec2d4168949446600468","src/extensions/khr/get_physical_device_properties2.rs":"a9ad06c559390c43100b7c6ab3a339ef7ce9c6e909d5e934e51fcfee2e18eb2f","src/extensions/khr/get_surface_capabilities2.rs":"6f2f8a0c84c4b962a681a2c02216df6967c1a91da7d6655f82c7eab3052db081","src/extensions/khr/maintenance1.rs":"e19365a3ad201712a871887346564d82a8bddfa8a7134b0f84f48396e0c428dd","src/extensions/khr/maintenance3.rs":"e4022aa249d57a47133df4ab6c6e3884a1613af78ba8d7b12bbeeeb87d0a19ee","src/extensions/khr/maintenance4.rs":"23a1a123dfa5ca32741fca6f14ea0aae358563ba043dda201283dbdd56687a06","src/extensions/khr/mod.rs":"1af17e94a6c0f8a95a60ea407f2b9657eee755d17671e2f7bdcf8eb24fa0ea4d","src/extensions/khr/pipeline_executable_properties.rs":"e643476dde846db4b96d4a1eab9f6cd59f2366dae706f61dfd5b2a58b33e5739","src/extensions/khr/present_wait.rs":"6bc0ff08748650e5aaa303287abecf9cd47328cd285763fdb120c5bc1bed72fd","src/extensions/khr/push_descriptor.rs":"531b9026b2e3377b259a93097ca4a6327951d11c0582dad29ea4b4817b0b7f95","src/extensions/khr/ray_tracing_maintenance1.rs":"281095b60144574189cd63e7d55f537abe46281c3f0c0501937c2e1dc4102fe9","src/extensions/khr/ray_tracing_pipeline.rs":"1d84bbcce85e6f6392828ace82022a713a71fe3a1f85fab6ba30368ac7088e23","src/extensions/khr/surface.rs":"fa60900890cf901a0d3fcb9f066f72917a783b73baff93bb377d8d3f77c18ea5","src/extensions/khr/swapchain.rs":"ec23290bc929b3db2a403d47148426a817b05547073f4d12950f816db0a9b520","src/extensions/khr/synchronization2.rs":"8d4e880ffdda8e9f458fc4ccf6de04b92d6314121071d711404b43236c9816e5","src/extensions/khr/timeline_semaphore.rs":"b554829512a648fd1d9ab493955e7c088c1f1f3a50b8fb933211d2b5a03e5cde","src/extensions/khr/wayland_surface.rs":"2d7b8423e5b856e9185cfef804f7fededd621f60e5aac26d93e69aee055dafd1","src/extensions/khr/win32_surface.rs":"135fa0493b77b322fa3478eba877848e9325bbf70d91f868862f637fbdeff507","src/extensions/khr/xcb_surface.rs":"c85bbce4d65f8c5ee4a11349183757e69df9331af50940f6befe6932ba3f6dc2","src/extensions/khr/xlib_surface.rs":"2175f140157e47af5096069e443799a1db373b2f6e9a0818a76a9398bc97bcea","src/extensions/mod.rs":"717bc2155a3d311ddc485dbf6313a0996e1906d15bd09be0aab776e33368eaa7","src/extensions/mvk/ios_surface.rs":"c268afccb727218f269649056a342688d9a93fa3f4f1888df7733d2d5c5030f6","src/extensions/mvk/macos_surface.rs":"1d9cdd0f818e2c209d5d11b1cbca6705351f097ef64697cb523e3f8e3b1cae93","src/extensions/mvk/mod.rs":"d03ac1a0144d1aca9ed1d0ce0c14b099f1fedb03b8108028b780a34f64de604c","src/extensions/nn/mod.rs":"b32935320aa2af18b129868d52d4042596b3c22046cd650a4e9e75c5f3973eb3","src/extensions/nn/vi_surface.rs":"27f09bf182967353ce5c0dc73ea89eab0f89ac3d5d18b9574b755cb3b6ff214b","src/extensions/nv/coverage_reduction_mode.rs":"428348e0876108b63dbbdce55218403c2481af902aba463633f9d4d62151c4c9","src/extensions/nv/device_diagnostic_checkpoints.rs":"8faca3ef4c99c5179996c8899c15489e1978d01fc7614248ac07057874d78f72","src/extensions/nv/mesh_shader.rs":"2bdbdf131db157d5e4f10beacdcc5cfdf54b4d296a0c0bf1239259ba32d4c76b","src/extensions/nv/mod.rs":"cb7e4f152f515c8a8beefcb7b2ff8a65e6d5932daf34139fb438c60f894e5fc2","src/extensions/nv/ray_tracing.rs":"a5c5faeb624542d13b0bb08e9434ae7604120a89e4e00a8430046c3cc218a9c1","src/instance.rs":"1afd01655c650480bffc1b6963e510632b92dc36733594c12aa3032415669270","src/lib.rs":"3dc222b92b417c0985e7ca5cd131f2966f02f038c578076962f028419edc05fa","src/prelude.rs":"035dbe3e825ff83b0af5b22ed428d95139ff16f65c6039419275a4a5820f499d","src/util.rs":"55eed33491cf1fa29ccf7f591aeba2c0bee2c7eae9c979124f27c800567104aa","src/vk.rs":"234a101311b07c82cca72db451ddf953e4cd385a6b7fd42fa4e8f659e8089e71","src/vk/aliases.rs":"c6d43e3073a3000e8ccaa1a131112a6129c22e699d559a53762fd7d99bf66e30","src/vk/bitflags.rs":"fa4e2337f029f3cb2c91b51a78ab48b2eeed64d07bc9d872783c06624aff5171","src/vk/const_debugs.rs":"b299897a023c200bd973addd736aa7b7110ce108d4012537679c0353d507af65","src/vk/constants.rs":"6e21377b7238d9c94174a97e6ebdc6e3401a2c32ef32e211142448eed1d972d7","src/vk/definitions.rs":"242aace0047bf09fa344771b8443c98d63fbcbdf0af6b38e120d37e2c83bafc5","src/vk/enums.rs":"4faea35666df46f2698b4eed1171dd916180959e06bdae43814f2ac8e9b6ce9b","src/vk/extensions.rs":"2d10226fb700efbf198ab158d2d8af6bb94563905023cd66cd81a1c9a7250dbc","src/vk/feature_extensions.rs":"c875cf2a7b02a8a8fa31f3bc8794ec526c0870b470e7a308b5b256402dc8125e","src/vk/features.rs":"46633698d0275ae55d4372403d76b09763e762e8db9fec0688f40d8204ce221b","src/vk/macros.rs":"5fde17e47d5a102bfc74dfd9ad024938d676950afae7fe932dc697cb95a9f5e4","src/vk/native.rs":"0e3d2c92be3f8b8b62d896136d1bcbdd8a9406f292aa912f646a6ed23fd96cb6","src/vk/platform_types.rs":"fc4143ac65aead425694fd4dd9f50a7c1aebe35e23c872050df5368c31694375","src/vk/prelude.rs":"8e1cf47901f63b64a1490011eb1572a7ce8401a1559cca6f057645bd2d85e035","tests/constant_size_arrays.rs":"fdd726fcebc3b05900a0d24a05826f4a19e99bc71f8f35bacc958a1e10de1013","tests/display.rs":"d294396bb5b2210432724cccc0a56e105bab8743e180d4ad7cc675a200c09539"},"package":"28bf19c1f0a470be5fbf7522a308a05df06610252c5bcf5143e1b23f629a9a03"} \ No newline at end of file diff --git a/third_party/rust/ash/Cargo.toml b/third_party/rust/ash/Cargo.toml new file mode 100644 index 0000000000..429cbf7b24 --- /dev/null +++ b/third_party/rust/ash/Cargo.toml @@ -0,0 +1,53 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +rust-version = "1.59.0" +name = "ash" +version = "0.37.2+1.3.238" +authors = [ + "Maik Klein ", + "Benjamin Saunders ", + "Marijn Suijten ", +] +description = "Vulkan bindings for Rust" +documentation = "https://docs.rs/ash" +readme = "README.md" +keywords = [ + "vulkan", + "graphic", +] +license = "MIT OR Apache-2.0" +repository = "https://github.com/MaikKlein/ash" + +[package.metadata.release] +no-dev-version = true + +[package.metadata.docs.rs] +all-features = true +rustdoc-args = [ + "--cfg", + "docsrs", +] + +[dependencies.libloading] +version = "0.7" +optional = true + +[features] +debug = [] +default = [ + "loaded", + "debug", +] +linked = [] +loaded = ["libloading"] diff --git a/third_party/rust/ash/LICENSE-APACHE b/third_party/rust/ash/LICENSE-APACHE new file mode 100644 index 0000000000..0078a142e8 --- /dev/null +++ b/third_party/rust/ash/LICENSE-APACHE @@ -0,0 +1,67 @@ +Apache License + +Version 2.0, January 2004 + +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + +You must give any other recipients of the Work or Derivative Works a copy of this License; and +You must cause any modified files to carry prominent notices stating that You changed the files; and +You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and +If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + +You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +Copyright 2016 Maik Klein + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/third_party/rust/ash/LICENSE-MIT b/third_party/rust/ash/LICENSE-MIT new file mode 100644 index 0000000000..e17f80b38f --- /dev/null +++ b/third_party/rust/ash/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright (c) 2016 ASH + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/third_party/rust/ash/README.md b/third_party/rust/ash/README.md new file mode 100644 index 0000000000..12c0892ce3 --- /dev/null +++ b/third_party/rust/ash/README.md @@ -0,0 +1,289 @@ +# Ash + +A very lightweight wrapper around Vulkan + +[![Crates.io Version](https://img.shields.io/crates/v/ash.svg)](https://crates.io/crates/ash) +[![Documentation](https://docs.rs/ash/badge.svg)](https://docs.rs/ash) +[![Build Status](https://github.com/MaikKlein/ash/workflows/CI/badge.svg)](https://github.com/MaikKlein/ash/actions?workflow=CI) +[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE-MIT) +[![LICENSE](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE-APACHE) +[![Join the chat at https://gitter.im/MaikKlein/ash](https://badges.gitter.im/MaikKlein/ash.svg)](https://gitter.im/MaikKlein/ash?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +## Overview +- [x] A true Vulkan API without compromises +- [x] Convenience features without limiting functionality +- [x] Additional type safety +- [x] Device local function pointer loading +- [x] No validation, everything is **unsafe** +- [x] Generated from `vk.xml` +- [x] Support for Vulkan `1.1`, `1.2`, `1.3` + +## ⚠️ Semver compatibility warning +The Vulkan Video bindings are experimental and still seeing breaking changes in their upstream specification, and are only provided by Ash for early adopters. All related functions and types are semver-exempt [^1] (we allow breaking API changes while releasing Ash with non-breaking semver bumps). + +[^1]: `generator` complexity makes it so that we cannot easily hide these bindings behind a non-`default` feature flag, and they are widespread across the generated codebase. + +## Features +### Explicit returns with `Result` +```rust +// function signature +pub fn create_instance(&self, + create_info: &vk::InstanceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>) + -> Result { .. } +let instance = entry.create_instance(&create_info, None) + .expect("Instance creation error"); +``` + + +### `Vec` instead of mutable slices + +```rust +pub fn get_swapchain_images(&self, + swapchain: vk::SwapchainKHR) + -> VkResult>; +let present_images = swapchain_loader.get_swapchain_images_khr(swapchain).unwrap(); +``` +*Note*: Functions don't return `Vec` if this would limit the functionality. See `p_next`. + +### Slices +```rust +pub fn cmd_pipeline_barrier(&self, + command_buffer: vk::CommandBuffer, + src_stage_mask: vk::PipelineStageFlags, + dst_stage_mask: vk::PipelineStageFlags, + dependency_flags: vk::DependencyFlags, + memory_barriers: &[vk::MemoryBarrier], + buffer_memory_barriers: &[vk::BufferMemoryBarrier], + image_memory_barriers: &[vk::ImageMemoryBarrier]); +``` + +### Strongly typed handles + +Each Vulkan handle type is exposed as a newtyped struct for improved type safety. Null handles can be constructed with +`T::null()`, and handles may be freely converted to and from `u64` with `Handle::from_raw` and `Handle::as_raw` for +interop with non-Ash Vulkan code. + +### Default implementation for all types +```rust +// No need to manually set the structure type +let desc_alloc_info = vk::DescriptorSetAllocateInfo { + descriptor_pool: self.pool, + descriptor_set_count: self.layouts.len() as u32, + p_set_layouts: self.layouts.as_ptr(), + ..Default::default() +}; +``` +### Builder pattern + +```rust +// We lose all lifetime information when we call `.build()`. Be careful! +let queue_info = [vk::DeviceQueueCreateInfo::builder() + .queue_family_index(queue_family_index) + .queue_priorities(&priorities) + .build()]; + +// We don't need to call `.build()` here because builders implement `Deref`. +let device_create_info = vk::DeviceCreateInfo::builder() + .queue_create_infos(&queue_info) + .enabled_extension_names(&device_extension_names_raw) + .enabled_features(&features); + +let device: Device = instance + .create_device(pdevice, &device_create_info, None) + .unwrap(); +``` + +To not lose this lifetime single items can be "cast" to a slice of length _one_ with `std::slice::from_ref` while still taking advantage of `Deref`: + +```rust +let queue_info = vk::DeviceQueueCreateInfo::builder() + .queue_family_index(queue_family_index) + .queue_priorities(&priorities); + +let device_create_info = vk::DeviceCreateInfo::builder() + .queue_create_infos(std::slice::from_ref(&queue_info)) + ...; +``` + +Builders have an explicit lifetime, and are marked as `#[repr(transparent)]`. +```rust +#[repr(transparent)] +pub struct DeviceCreateInfoBuilder<'a> { + inner: DeviceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> DeviceCreateInfoBuilder<'a> { + //... + pub fn queue_create_infos( + mut self, + queue_create_infos: &'a [DeviceQueueCreateInfo], + ) -> DeviceCreateInfoBuilder<'a> {...} + //... +``` + +Every reference has to live as long as the builder itself. Builders implement `Deref` targeting their corresponding Vulkan struct, so references to builders can be passed directly +to Vulkan functions. + +Calling `.build()` will **discard** that lifetime because Vulkan structs use raw pointers internally. This should be avoided as much as possible because this can easily lead to dangling pointers. If `.build()` has to be called, it should be called as late as possible. [Lifetimes of temporaries](https://doc.rust-lang.org/reference/expressions.html#temporary-lifetimes) are extended to the enclosing statement, ensuring they are valid for the duration of a Vulkan call occurring in the same statement. + + +### Pointer chains + +```rust +let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); +let mut corner = + vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); +; +let mut device_create_info = vk::DeviceCreateInfo::builder() + .push_next(&mut corner) + .push_next(&mut variable_pointers); +``` + +Pointer chains in builders differ from raw Vulkan. Instead of chaining every struct manually, you instead use `.push_next` on the struct that you are going to pass into the function. Those structs then get *prepended* into the chain. + +`push_next` is also type checked, you can only add valid structs to the chain. Both the structs and the builders can be passed into `push_next`. Only builders for structs that can be passed into functions will implement a `push_next`. + + +### Flags and constants as associated constants + +```rust +// Bitflag +vk::AccessFlags::COLOR_ATTACHMENT_READ | vk::AccessFlags::COLOR_ATTACHMENT_WRITE +``` + +```rust +// Constant +vk::PipelineBindPoint::GRAPHICS, +``` +### Debug/Display for Flags + +```rust +let flag = vk::AccessFlags::COLOR_ATTACHMENT_READ + | vk::AccessFlags::COLOR_ATTACHMENT_WRITE; +println!("Debug: {:?}", flag); +println!("Display: {}", flag); +// Prints: +// Debug: AccessFlags(110000000) +// Display: COLOR_ATTACHMENT_READ | COLOR_ATTACHMENT_WRITE +``` + +### Function pointer loading +Ash also takes care of loading the function pointers. Function pointers are split into 3 categories. + +* Entry: Loads the Vulkan library. Needs to outlive `Instance` and `Device`. +* Instance: Loads instance level functions. Needs to outlive the `Device`s it has created. +* Device: Loads device **local** functions. + +The loader is just one possible implementation: + +* Device level functions are retrieved on a per device basis. +* Everything is loaded by default, functions that failed to load are initialized to a function that always panics. +* Do not call Vulkan 1.1 functions if you have created a 1.0 instance. Doing so will result in a panic. + +Custom loaders can be implemented. + +### Extension loading +Additionally, every Vulkan extension has to be loaded explicitly. You can find all extensions under [ash::extensions](https://github.com/MaikKlein/ash/tree/master/ash/src/extensions). +```rust +use ash::extensions::khr::Swapchain; +let swapchain_loader = Swapchain::new(&instance, &device); +let swapchain = swapchain_loader.create_swapchain(&swapchain_create_info).unwrap(); +``` + +### Raw function pointers + +Raw function pointers are available, if something hasn't been exposed yet in the higher level API. Please open an issue if anything is missing. + +```rust +device.fp_v1_0().destroy_device(...); +``` + +### Support for extension names +```rust +use ash::extensions::{Swapchain, XlibSurface, Surface, DebugReport}; +#[cfg(all(unix, not(target_os = "android")))] +fn extension_names() -> Vec<*const i8> { + vec![ + Surface::name().as_ptr(), + XlibSurface::name().as_ptr(), + DebugReport::name().as_ptr() + ] +} +``` + +### Implicit handles +Handles from Instance or Device are passed implicitly. +```rust +pub fn create_command_pool(&self, + create_info: &vk::CommandPoolCreateInfo) + -> VkResult; + +let pool = device.create_command_pool(&pool_create_info).unwrap(); +``` + +### Optional linking + +The default `loaded` cargo feature will dynamically load the default Vulkan library for the current platform with `Entry::load`, meaning that the build environment does not have to have Vulkan development packages installed. + +If, on the other hand, your application cannot handle Vulkan being missing at runtime, you can instead enable the `linked` feature, which will link your binary with the Vulkan loader directly and expose the infallible `Entry::linked`. + +## Example +You can find the examples [here](https://github.com/MaikKlein/ash/tree/master/examples). +All examples currently require: the LunarG Validation layers and a Vulkan library that is visible in your `PATH`. An easy way to get started is to use the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/) +#### Windows +Make sure that you have a Vulkan ready driver and install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/). +#### Linux +Make sure that you have a Vulkan ready driver and install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/). You also have to add the library and layers to your path. Have a look at my [post](http://askubuntu.com/a/803110/77183) if you are unsure how to do that. +#### macOS +Install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/). The installer puts the SDK in `$HOME/VulkanSDK/` by default. You will need to set the following environment variables when running cargo: +```sh +VULKAN_SDK=$HOME/VulkanSDK//macOS \ +DYLD_FALLBACK_LIBRARY_PATH=$VULKAN_SDK/lib \ +VK_ICD_FILENAMES=$VULKAN_SDK/share/vulkan/icd.d/MoltenVK_icd.json \ +VK_LAYER_PATH=$VULKAN_SDK/share/vulkan/explicit_layer.d \ +cargo run ... +``` + +### [Triangle](https://github.com/MaikKlein/ash/blob/master/examples/src/bin/triangle.rs) +Displays a triangle with vertex colors. +``` +cd examples +cargo run --bin triangle +``` + +![screenshot](http://i.imgur.com/PQZcL6w.jpg) + +### [Texture](https://github.com/MaikKlein/ash/blob/master/examples/src/bin/texture.rs) +Displays a texture on a quad. +``` +cd examples +cargo run --bin texture +``` +![texture](http://i.imgur.com/trow00H.png) + +## Useful resources + +### Examples + +* [vulkan-tutorial-rust](https://github.com/Usami-Renko/vulkan-tutorial-rust) - A port of [vulkan-tutorial.com](https://vulkan-tutorial.com). +* [ash-sample-progression](https://github.com/bzm3r/ash-sample-progression) - A port of the LunarG examples. +* [ash-nv-rt](https://github.com/gwihlidal/ash-nv-rt) A raytracing example for ash. + +### Utility libraries +* [vk-sync](https://github.com/gwihlidal/vk-sync-rs) - Simplified Vulkan synchronization logic, written in rust. +* [vk-mem-rs](https://github.com/gwihlidal/vk-mem-rs) - This crate provides an FFI layer and idiomatic rust wrappers for the excellent AMD Vulkan Memory Allocator (VMA) C/C++ library. +* [gpu-allocator](https://github.com/Traverse-Research/gpu-allocator) - Memory allocator written in pure Rust for GPU memory in Vulkan and in the future DirectX 12 +* [lahar](https://github.com/Ralith/lahar) - Tools for asynchronously uploading data to a Vulkan device. + +### Libraries that use ash +* [gfx-rs](https://github.com/gfx-rs/gfx) - gfx-rs is a low-level, cross-platform graphics abstraction library in Rust. + +## A thanks to + +* [Api with no secrets](https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1) +* [Vulkan tutorial](http://jhenriques.net/development.html) +* [Vulkan examples](https://github.com/SaschaWillems/Vulkan) +* [Vulkan tutorial](https://vulkan-tutorial.com/) +* [Vulkano](https://github.com/vulkano-rs/vulkano) +* [vk-rs](https://github.com/Osspial/vk-rs) diff --git a/third_party/rust/ash/build.rs b/third_party/rust/ash/build.rs new file mode 100644 index 0000000000..ba6e61d492 --- /dev/null +++ b/third_party/rust/ash/build.rs @@ -0,0 +1,24 @@ +fn main() { + #[cfg(feature = "linked")] + { + use std::env; + + let target_family = env::var("CARGO_CFG_TARGET_FAMILY").unwrap(); + let target_pointer_width = env::var("CARGO_CFG_TARGET_POINTER_WIDTH").unwrap(); + + println!("cargo:rerun-if-env-changed=VULKAN_SDK"); + if let Ok(var) = env::var("VULKAN_SDK") { + let suffix = match (&*target_family, &*target_pointer_width) { + ("windows", "32") => "Lib32", + ("windows", "64") => "Lib", + _ => "lib", + }; + println!("cargo:rustc-link-search={}/{}", var, suffix); + } + let lib = match &*target_family { + "windows" => "vulkan-1", + _ => "vulkan", + }; + println!("cargo:rustc-link-lib={}", lib); + } +} diff --git a/third_party/rust/ash/src/device.rs b/third_party/rust/ash/src/device.rs new file mode 100644 index 0000000000..60a91ae155 --- /dev/null +++ b/third_party/rust/ash/src/device.rs @@ -0,0 +1,2707 @@ +#![allow(clippy::trivially_copy_pass_by_ref)] +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use std::mem; +use std::os::raw::c_void; +use std::ptr; + +/// +#[derive(Clone)] +pub struct Device { + pub(crate) handle: vk::Device, + + pub(crate) device_fn_1_0: vk::DeviceFnV1_0, + pub(crate) device_fn_1_1: vk::DeviceFnV1_1, + pub(crate) device_fn_1_2: vk::DeviceFnV1_2, + pub(crate) device_fn_1_3: vk::DeviceFnV1_3, +} + +impl Device { + pub unsafe fn load(instance_fn: &vk::InstanceFnV1_0, device: vk::Device) -> Self { + let load_fn = |name: &std::ffi::CStr| { + mem::transmute((instance_fn.get_device_proc_addr)(device, name.as_ptr())) + }; + + Self { + handle: device, + + device_fn_1_0: vk::DeviceFnV1_0::load(load_fn), + device_fn_1_1: vk::DeviceFnV1_1::load(load_fn), + device_fn_1_2: vk::DeviceFnV1_2::load(load_fn), + device_fn_1_3: vk::DeviceFnV1_3::load(load_fn), + } + } + + #[inline] + pub fn handle(&self) -> vk::Device { + self.handle + } +} + +/// Vulkan core 1.3 +#[allow(non_camel_case_types)] +impl Device { + #[inline] + pub fn fp_v1_3(&self) -> &vk::DeviceFnV1_3 { + &self.device_fn_1_3 + } + + /// + #[inline] + pub unsafe fn create_private_data_slot( + &self, + create_info: &vk::PrivateDataSlotCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut private_data_slot = mem::zeroed(); + (self.device_fn_1_3.create_private_data_slot)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut private_data_slot, + ) + .result_with_success(private_data_slot) + } + + /// + #[inline] + pub unsafe fn destroy_private_data_slot( + &self, + private_data_slot: vk::PrivateDataSlot, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_3.destroy_private_data_slot)( + self.handle, + private_data_slot, + allocation_callbacks.as_raw_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn set_private_data( + &self, + object: T, + private_data_slot: vk::PrivateDataSlot, + data: u64, + ) -> VkResult<()> { + (self.device_fn_1_3.set_private_data)( + self.handle, + T::TYPE, + object.as_raw(), + private_data_slot, + data, + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_private_data( + &self, + object: T, + private_data_slot: vk::PrivateDataSlot, + ) -> u64 { + let mut data = mem::zeroed(); + (self.device_fn_1_3.get_private_data)( + self.handle, + T::TYPE, + object.as_raw(), + private_data_slot, + &mut data, + ); + data + } + + /// + #[inline] + pub unsafe fn cmd_pipeline_barrier2( + &self, + command_buffer: vk::CommandBuffer, + dependency_info: &vk::DependencyInfo, + ) { + (self.device_fn_1_3.cmd_pipeline_barrier2)(command_buffer, dependency_info) + } + + /// + #[inline] + pub unsafe fn cmd_reset_event2( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + stage_mask: vk::PipelineStageFlags2, + ) { + (self.device_fn_1_3.cmd_reset_event2)(command_buffer, event, stage_mask) + } + + /// + #[inline] + pub unsafe fn cmd_set_event2( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + dependency_info: &vk::DependencyInfo, + ) { + (self.device_fn_1_3.cmd_set_event2)(command_buffer, event, dependency_info) + } + + /// + #[inline] + pub unsafe fn cmd_wait_events2( + &self, + command_buffer: vk::CommandBuffer, + events: &[vk::Event], + dependency_infos: &[vk::DependencyInfo], + ) { + assert_eq!(events.len(), dependency_infos.len()); + (self.device_fn_1_3.cmd_wait_events2)( + command_buffer, + events.len() as u32, + events.as_ptr(), + dependency_infos.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_write_timestamp2( + &self, + command_buffer: vk::CommandBuffer, + stage: vk::PipelineStageFlags2, + query_pool: vk::QueryPool, + query: u32, + ) { + (self.device_fn_1_3.cmd_write_timestamp2)(command_buffer, stage, query_pool, query) + } + + /// + #[inline] + pub unsafe fn queue_submit2( + &self, + queue: vk::Queue, + submits: &[vk::SubmitInfo2], + fence: vk::Fence, + ) -> VkResult<()> { + (self.device_fn_1_3.queue_submit2)(queue, submits.len() as u32, submits.as_ptr(), fence) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_copy_buffer2( + &self, + command_buffer: vk::CommandBuffer, + copy_buffer_info: &vk::CopyBufferInfo2, + ) { + (self.device_fn_1_3.cmd_copy_buffer2)(command_buffer, copy_buffer_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_image2( + &self, + command_buffer: vk::CommandBuffer, + copy_image_info: &vk::CopyImageInfo2, + ) { + (self.device_fn_1_3.cmd_copy_image2)(command_buffer, copy_image_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_buffer_to_image2( + &self, + command_buffer: vk::CommandBuffer, + copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2, + ) { + (self.device_fn_1_3.cmd_copy_buffer_to_image2)(command_buffer, copy_buffer_to_image_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_image_to_buffer2( + &self, + command_buffer: vk::CommandBuffer, + copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2, + ) { + (self.device_fn_1_3.cmd_copy_image_to_buffer2)(command_buffer, copy_image_to_buffer_info) + } + /// + #[inline] + pub unsafe fn cmd_blit_image2( + &self, + command_buffer: vk::CommandBuffer, + blit_image_info: &vk::BlitImageInfo2, + ) { + (self.device_fn_1_3.cmd_blit_image2)(command_buffer, blit_image_info) + } + /// + #[inline] + pub unsafe fn cmd_resolve_image2( + &self, + command_buffer: vk::CommandBuffer, + resolve_image_info: &vk::ResolveImageInfo2, + ) { + (self.device_fn_1_3.cmd_resolve_image2)(command_buffer, resolve_image_info) + } + + /// + #[inline] + pub unsafe fn cmd_begin_rendering( + &self, + command_buffer: vk::CommandBuffer, + rendering_info: &vk::RenderingInfo, + ) { + (self.device_fn_1_3.cmd_begin_rendering)(command_buffer, rendering_info) + } + + /// + #[inline] + pub unsafe fn cmd_end_rendering(&self, command_buffer: vk::CommandBuffer) { + (self.device_fn_1_3.cmd_end_rendering)(command_buffer) + } + + /// + #[inline] + pub unsafe fn cmd_set_cull_mode( + &self, + command_buffer: vk::CommandBuffer, + cull_mode: vk::CullModeFlags, + ) { + (self.device_fn_1_3.cmd_set_cull_mode)(command_buffer, cull_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_front_face( + &self, + command_buffer: vk::CommandBuffer, + front_face: vk::FrontFace, + ) { + (self.device_fn_1_3.cmd_set_front_face)(command_buffer, front_face) + } + + /// + #[inline] + pub unsafe fn cmd_set_primitive_topology( + &self, + command_buffer: vk::CommandBuffer, + primitive_topology: vk::PrimitiveTopology, + ) { + (self.device_fn_1_3.cmd_set_primitive_topology)(command_buffer, primitive_topology) + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport_with_count( + &self, + command_buffer: vk::CommandBuffer, + viewports: &[vk::Viewport], + ) { + (self.device_fn_1_3.cmd_set_viewport_with_count)( + command_buffer, + viewports.len() as u32, + viewports.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_scissor_with_count( + &self, + command_buffer: vk::CommandBuffer, + scissors: &[vk::Rect2D], + ) { + (self.device_fn_1_3.cmd_set_scissor_with_count)( + command_buffer, + scissors.len() as u32, + scissors.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_bind_vertex_buffers2( + &self, + command_buffer: vk::CommandBuffer, + first_binding: u32, + buffers: &[vk::Buffer], + offsets: &[vk::DeviceSize], + sizes: Option<&[vk::DeviceSize]>, + strides: Option<&[vk::DeviceSize]>, + ) { + assert_eq!(offsets.len(), buffers.len()); + let p_sizes = if let Some(sizes) = sizes { + assert_eq!(sizes.len(), buffers.len()); + sizes.as_ptr() + } else { + ptr::null() + }; + let p_strides = if let Some(strides) = strides { + assert_eq!(strides.len(), buffers.len()); + strides.as_ptr() + } else { + ptr::null() + }; + (self.device_fn_1_3.cmd_bind_vertex_buffers2)( + command_buffer, + first_binding, + buffers.len() as u32, + buffers.as_ptr(), + offsets.as_ptr(), + p_sizes, + p_strides, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_test_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_test_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_depth_test_enable)(command_buffer, depth_test_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_write_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_write_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_depth_write_enable)(command_buffer, depth_write_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_compare_op( + &self, + command_buffer: vk::CommandBuffer, + depth_compare_op: vk::CompareOp, + ) { + (self.device_fn_1_3.cmd_set_depth_compare_op)(command_buffer, depth_compare_op) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bounds_test_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_bounds_test_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_depth_bounds_test_enable)( + command_buffer, + depth_bounds_test_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_test_enable( + &self, + command_buffer: vk::CommandBuffer, + stencil_test_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_stencil_test_enable)(command_buffer, stencil_test_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_op( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + fail_op: vk::StencilOp, + pass_op: vk::StencilOp, + depth_fail_op: vk::StencilOp, + compare_op: vk::CompareOp, + ) { + (self.device_fn_1_3.cmd_set_stencil_op)( + command_buffer, + face_mask, + fail_op, + pass_op, + depth_fail_op, + compare_op, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_rasterizer_discard_enable( + &self, + command_buffer: vk::CommandBuffer, + rasterizer_discard_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_rasterizer_discard_enable)( + command_buffer, + rasterizer_discard_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bias_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_bias_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_depth_bias_enable)(command_buffer, depth_bias_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_primitive_restart_enable( + &self, + command_buffer: vk::CommandBuffer, + primitive_restart_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_primitive_restart_enable)( + command_buffer, + primitive_restart_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn get_device_buffer_memory_requirements( + &self, + create_info: &vk::DeviceBufferMemoryRequirements, + out: &mut vk::MemoryRequirements2, + ) { + (self.device_fn_1_3.get_device_buffer_memory_requirements)(self.handle, create_info, out) + } + + /// + #[inline] + pub unsafe fn get_device_image_memory_requirements( + &self, + create_info: &vk::DeviceImageMemoryRequirements, + out: &mut vk::MemoryRequirements2, + ) { + (self.device_fn_1_3.get_device_image_memory_requirements)(self.handle, create_info, out) + } + + /// Retrieve the number of elements to pass to [`get_device_image_sparse_memory_requirements()`][Self::get_device_image_sparse_memory_requirements()] + #[inline] + pub unsafe fn get_device_image_sparse_memory_requirements_len( + &self, + create_info: &vk::DeviceImageMemoryRequirements, + ) -> usize { + let mut count = 0; + (self + .device_fn_1_3 + .get_device_image_sparse_memory_requirements)( + self.handle, + create_info, + &mut count, + std::ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_device_image_sparse_memory_requirements_len()`][Self::get_device_image_sparse_memory_requirements_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_device_image_sparse_memory_requirements( + &self, + create_info: &vk::DeviceImageMemoryRequirements, + out: &mut [vk::SparseImageMemoryRequirements2], + ) { + let mut count = out.len() as u32; + (self + .device_fn_1_3 + .get_device_image_sparse_memory_requirements)( + self.handle, + create_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } +} + +/// Vulkan core 1.2 +#[allow(non_camel_case_types)] +impl Device { + #[inline] + pub fn fp_v1_2(&self) -> &vk::DeviceFnV1_2 { + &self.device_fn_1_2 + } + + /// + #[inline] + pub unsafe fn cmd_draw_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.device_fn_1_2.cmd_draw_indirect_count)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indexed_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.device_fn_1_2.cmd_draw_indexed_indirect_count)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn create_render_pass2( + &self, + create_info: &vk::RenderPassCreateInfo2, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut renderpass = mem::zeroed(); + (self.device_fn_1_2.create_render_pass2)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut renderpass, + ) + .result_with_success(renderpass) + } + + /// + #[inline] + pub unsafe fn cmd_begin_render_pass2( + &self, + command_buffer: vk::CommandBuffer, + render_pass_begin_info: &vk::RenderPassBeginInfo, + subpass_begin_info: &vk::SubpassBeginInfo, + ) { + (self.device_fn_1_2.cmd_begin_render_pass2)( + command_buffer, + render_pass_begin_info, + subpass_begin_info, + ); + } + + /// + #[inline] + pub unsafe fn cmd_next_subpass2( + &self, + command_buffer: vk::CommandBuffer, + subpass_begin_info: &vk::SubpassBeginInfo, + subpass_end_info: &vk::SubpassEndInfo, + ) { + (self.device_fn_1_2.cmd_next_subpass2)( + command_buffer, + subpass_begin_info, + subpass_end_info, + ); + } + + /// + #[inline] + pub unsafe fn cmd_end_render_pass2( + &self, + command_buffer: vk::CommandBuffer, + subpass_end_info: &vk::SubpassEndInfo, + ) { + (self.device_fn_1_2.cmd_end_render_pass2)(command_buffer, subpass_end_info); + } + + /// + #[inline] + pub unsafe fn reset_query_pool( + &self, + query_pool: vk::QueryPool, + first_query: u32, + query_count: u32, + ) { + (self.device_fn_1_2.reset_query_pool)(self.handle(), query_pool, first_query, query_count); + } + + /// + #[inline] + pub unsafe fn get_semaphore_counter_value(&self, semaphore: vk::Semaphore) -> VkResult { + let mut value = 0; + (self.device_fn_1_2.get_semaphore_counter_value)(self.handle(), semaphore, &mut value) + .result_with_success(value) + } + + /// + #[inline] + pub unsafe fn wait_semaphores( + &self, + wait_info: &vk::SemaphoreWaitInfo, + timeout: u64, + ) -> VkResult<()> { + (self.device_fn_1_2.wait_semaphores)(self.handle(), wait_info, timeout).result() + } + + /// + #[inline] + pub unsafe fn signal_semaphore(&self, signal_info: &vk::SemaphoreSignalInfo) -> VkResult<()> { + (self.device_fn_1_2.signal_semaphore)(self.handle(), signal_info).result() + } + + /// + #[inline] + pub unsafe fn get_buffer_device_address( + &self, + info: &vk::BufferDeviceAddressInfo, + ) -> vk::DeviceAddress { + (self.device_fn_1_2.get_buffer_device_address)(self.handle(), info) + } + + /// + #[inline] + pub unsafe fn get_buffer_opaque_capture_address( + &self, + info: &vk::BufferDeviceAddressInfo, + ) -> u64 { + (self.device_fn_1_2.get_buffer_opaque_capture_address)(self.handle(), info) + } + + /// + #[inline] + pub unsafe fn get_device_memory_opaque_capture_address( + &self, + info: &vk::DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64 { + (self.device_fn_1_2.get_device_memory_opaque_capture_address)(self.handle(), info) + } +} + +/// Vulkan core 1.1 +#[allow(non_camel_case_types)] +impl Device { + #[inline] + pub fn fp_v1_1(&self) -> &vk::DeviceFnV1_1 { + &self.device_fn_1_1 + } + + /// + #[inline] + pub unsafe fn bind_buffer_memory2( + &self, + bind_infos: &[vk::BindBufferMemoryInfo], + ) -> VkResult<()> { + (self.device_fn_1_1.bind_buffer_memory2)( + self.handle(), + bind_infos.len() as _, + bind_infos.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn bind_image_memory2( + &self, + bind_infos: &[vk::BindImageMemoryInfo], + ) -> VkResult<()> { + (self.device_fn_1_1.bind_image_memory2)( + self.handle(), + bind_infos.len() as _, + bind_infos.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_device_group_peer_memory_features( + &self, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, + ) -> vk::PeerMemoryFeatureFlags { + let mut peer_memory_features = mem::zeroed(); + (self.device_fn_1_1.get_device_group_peer_memory_features)( + self.handle(), + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features + } + + /// + #[inline] + pub unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: u32) { + (self.device_fn_1_1.cmd_set_device_mask)(command_buffer, device_mask); + } + + /// + #[inline] + pub unsafe fn cmd_dispatch_base( + &self, + command_buffer: vk::CommandBuffer, + base_group_x: u32, + base_group_y: u32, + base_group_z: u32, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, + ) { + (self.device_fn_1_1.cmd_dispatch_base)( + command_buffer, + base_group_x, + base_group_y, + base_group_z, + group_count_x, + group_count_y, + group_count_z, + ); + } + + /// + #[inline] + pub unsafe fn get_image_memory_requirements2( + &self, + info: &vk::ImageMemoryRequirementsInfo2, + out: &mut vk::MemoryRequirements2, + ) { + (self.device_fn_1_1.get_image_memory_requirements2)(self.handle(), info, out); + } + + /// + #[inline] + pub unsafe fn get_buffer_memory_requirements2( + &self, + info: &vk::BufferMemoryRequirementsInfo2, + out: &mut vk::MemoryRequirements2, + ) { + (self.device_fn_1_1.get_buffer_memory_requirements2)(self.handle(), info, out); + } + + /// Retrieve the number of elements to pass to [`get_image_sparse_memory_requirements2()`][Self::get_image_sparse_memory_requirements2()] + #[inline] + pub unsafe fn get_image_sparse_memory_requirements2_len( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2, + ) -> usize { + let mut count = 0; + (self.device_fn_1_1.get_image_sparse_memory_requirements2)( + self.handle(), + info, + &mut count, + ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_image_sparse_memory_requirements2_len()`][Self::get_image_sparse_memory_requirements2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_image_sparse_memory_requirements2( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2, + out: &mut [vk::SparseImageMemoryRequirements2], + ) { + let mut count = out.len() as u32; + (self.device_fn_1_1.get_image_sparse_memory_requirements2)( + self.handle(), + info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + /// + #[inline] + pub unsafe fn trim_command_pool( + &self, + command_pool: vk::CommandPool, + flags: vk::CommandPoolTrimFlags, + ) { + (self.device_fn_1_1.trim_command_pool)(self.handle(), command_pool, flags); + } + + /// + #[inline] + pub unsafe fn create_sampler_ycbcr_conversion( + &self, + create_info: &vk::SamplerYcbcrConversionCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut ycbcr_conversion = mem::zeroed(); + (self.device_fn_1_1.create_sampler_ycbcr_conversion)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut ycbcr_conversion, + ) + .result_with_success(ycbcr_conversion) + } + + /// + #[inline] + pub unsafe fn destroy_sampler_ycbcr_conversion( + &self, + ycbcr_conversion: vk::SamplerYcbcrConversion, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_1.destroy_sampler_ycbcr_conversion)( + self.handle(), + ycbcr_conversion, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_descriptor_update_template( + &self, + create_info: &vk::DescriptorUpdateTemplateCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut descriptor_update_template = mem::zeroed(); + (self.device_fn_1_1.create_descriptor_update_template)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut descriptor_update_template, + ) + .result_with_success(descriptor_update_template) + } + + /// + #[inline] + pub unsafe fn destroy_descriptor_update_template( + &self, + descriptor_update_template: vk::DescriptorUpdateTemplate, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_1.destroy_descriptor_update_template)( + self.handle(), + descriptor_update_template, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn update_descriptor_set_with_template( + &self, + descriptor_set: vk::DescriptorSet, + descriptor_update_template: vk::DescriptorUpdateTemplate, + data: *const c_void, + ) { + (self.device_fn_1_1.update_descriptor_set_with_template)( + self.handle(), + descriptor_set, + descriptor_update_template, + data, + ); + } + + /// + #[inline] + pub unsafe fn get_descriptor_set_layout_support( + &self, + create_info: &vk::DescriptorSetLayoutCreateInfo, + out: &mut vk::DescriptorSetLayoutSupport, + ) { + (self.device_fn_1_1.get_descriptor_set_layout_support)(self.handle(), create_info, out); + } +} + +/// Vulkan core 1.0 +#[allow(non_camel_case_types)] +impl Device { + #[inline] + pub fn fp_v1_0(&self) -> &vk::DeviceFnV1_0 { + &self.device_fn_1_0 + } + + /// + #[inline] + pub unsafe fn destroy_device(&self, allocation_callbacks: Option<&vk::AllocationCallbacks>) { + (self.device_fn_1_0.destroy_device)(self.handle(), allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn destroy_sampler( + &self, + sampler: vk::Sampler, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_sampler)( + self.handle(), + sampler, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn free_memory( + &self, + memory: vk::DeviceMemory, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.free_memory)(self.handle(), memory, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn free_command_buffers( + &self, + command_pool: vk::CommandPool, + command_buffers: &[vk::CommandBuffer], + ) { + (self.device_fn_1_0.free_command_buffers)( + self.handle(), + command_pool, + command_buffers.len() as u32, + command_buffers.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_event( + &self, + create_info: &vk::EventCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut event = mem::zeroed(); + (self.device_fn_1_0.create_event)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut event, + ) + .result_with_success(event) + } + + /// Returns [`true`] if the event was set, and [`false`] if the event was reset, otherwise it will + /// return the error code. + /// + #[inline] + pub unsafe fn get_event_status(&self, event: vk::Event) -> VkResult { + let err_code = (self.device_fn_1_0.get_event_status)(self.handle(), event); + match err_code { + vk::Result::EVENT_SET => Ok(true), + vk::Result::EVENT_RESET => Ok(false), + _ => Err(err_code), + } + } + + /// + #[inline] + pub unsafe fn set_event(&self, event: vk::Event) -> VkResult<()> { + (self.device_fn_1_0.set_event)(self.handle(), event).result() + } + + /// + #[inline] + pub unsafe fn reset_event(&self, event: vk::Event) -> VkResult<()> { + (self.device_fn_1_0.reset_event)(self.handle(), event).result() + } + /// + #[inline] + pub unsafe fn cmd_set_event( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + stage_mask: vk::PipelineStageFlags, + ) { + (self.device_fn_1_0.cmd_set_event)(command_buffer, event, stage_mask); + } + /// + #[inline] + pub unsafe fn cmd_reset_event( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + stage_mask: vk::PipelineStageFlags, + ) { + (self.device_fn_1_0.cmd_reset_event)(command_buffer, event, stage_mask); + } + + /// + #[inline] + pub unsafe fn cmd_wait_events( + &self, + command_buffer: vk::CommandBuffer, + events: &[vk::Event], + src_stage_mask: vk::PipelineStageFlags, + dst_stage_mask: vk::PipelineStageFlags, + memory_barriers: &[vk::MemoryBarrier], + buffer_memory_barriers: &[vk::BufferMemoryBarrier], + image_memory_barriers: &[vk::ImageMemoryBarrier], + ) { + (self.device_fn_1_0.cmd_wait_events)( + command_buffer, + events.len() as _, + events.as_ptr(), + src_stage_mask, + dst_stage_mask, + memory_barriers.len() as _, + memory_barriers.as_ptr(), + buffer_memory_barriers.len() as _, + buffer_memory_barriers.as_ptr(), + image_memory_barriers.len() as _, + image_memory_barriers.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_fence( + &self, + fence: vk::Fence, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_fence)(self.handle(), fence, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn destroy_event( + &self, + event: vk::Event, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_event)(self.handle(), event, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn destroy_image( + &self, + image: vk::Image, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_image)(self.handle(), image, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn destroy_command_pool( + &self, + pool: vk::CommandPool, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_command_pool)( + self.handle(), + pool, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_image_view( + &self, + image_view: vk::ImageView, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_image_view)( + self.handle(), + image_view, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_render_pass( + &self, + renderpass: vk::RenderPass, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_render_pass)( + self.handle(), + renderpass, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_framebuffer( + &self, + framebuffer: vk::Framebuffer, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_framebuffer)( + self.handle(), + framebuffer, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_pipeline_layout( + &self, + pipeline_layout: vk::PipelineLayout, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_pipeline_layout)( + self.handle(), + pipeline_layout, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_pipeline_cache( + &self, + pipeline_cache: vk::PipelineCache, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_pipeline_cache)( + self.handle(), + pipeline_cache, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_buffer( + &self, + buffer: vk::Buffer, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_buffer)( + self.handle(), + buffer, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_shader_module( + &self, + shader: vk::ShaderModule, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_shader_module)( + self.handle(), + shader, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_pipeline( + &self, + pipeline: vk::Pipeline, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_pipeline)( + self.handle(), + pipeline, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_semaphore( + &self, + semaphore: vk::Semaphore, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_semaphore)( + self.handle(), + semaphore, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_descriptor_pool( + &self, + pool: vk::DescriptorPool, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_descriptor_pool)( + self.handle(), + pool, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_query_pool( + &self, + pool: vk::QueryPool, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_query_pool)( + self.handle(), + pool, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_descriptor_set_layout( + &self, + layout: vk::DescriptorSetLayout, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_descriptor_set_layout)( + self.handle(), + layout, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn free_descriptor_sets( + &self, + pool: vk::DescriptorPool, + descriptor_sets: &[vk::DescriptorSet], + ) -> VkResult<()> { + (self.device_fn_1_0.free_descriptor_sets)( + self.handle(), + pool, + descriptor_sets.len() as u32, + descriptor_sets.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn update_descriptor_sets( + &self, + descriptor_writes: &[vk::WriteDescriptorSet], + descriptor_copies: &[vk::CopyDescriptorSet], + ) { + (self.device_fn_1_0.update_descriptor_sets)( + self.handle(), + descriptor_writes.len() as u32, + descriptor_writes.as_ptr(), + descriptor_copies.len() as u32, + descriptor_copies.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_sampler( + &self, + create_info: &vk::SamplerCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut sampler = mem::zeroed(); + (self.device_fn_1_0.create_sampler)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut sampler, + ) + .result_with_success(sampler) + } + + /// + #[inline] + pub unsafe fn cmd_blit_image( + &self, + command_buffer: vk::CommandBuffer, + src_image: vk::Image, + src_image_layout: vk::ImageLayout, + dst_image: vk::Image, + dst_image_layout: vk::ImageLayout, + regions: &[vk::ImageBlit], + filter: vk::Filter, + ) { + (self.device_fn_1_0.cmd_blit_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + regions.len() as _, + regions.as_ptr(), + filter, + ); + } + + /// + #[inline] + pub unsafe fn cmd_resolve_image( + &self, + command_buffer: vk::CommandBuffer, + src_image: vk::Image, + src_image_layout: vk::ImageLayout, + dst_image: vk::Image, + dst_image_layout: vk::ImageLayout, + regions: &[vk::ImageResolve], + ) { + (self.device_fn_1_0.cmd_resolve_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_fill_buffer( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + size: vk::DeviceSize, + data: u32, + ) { + (self.device_fn_1_0.cmd_fill_buffer)(command_buffer, buffer, offset, size, data); + } + + /// + #[inline] + pub unsafe fn cmd_update_buffer( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + data: &[u8], + ) { + (self.device_fn_1_0.cmd_update_buffer)( + command_buffer, + buffer, + offset, + data.len() as u64, + data.as_ptr() as _, + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_buffer( + &self, + command_buffer: vk::CommandBuffer, + src_buffer: vk::Buffer, + dst_buffer: vk::Buffer, + regions: &[vk::BufferCopy], + ) { + (self.device_fn_1_0.cmd_copy_buffer)( + command_buffer, + src_buffer, + dst_buffer, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_image_to_buffer( + &self, + command_buffer: vk::CommandBuffer, + src_image: vk::Image, + src_image_layout: vk::ImageLayout, + dst_buffer: vk::Buffer, + regions: &[vk::BufferImageCopy], + ) { + (self.device_fn_1_0.cmd_copy_image_to_buffer)( + command_buffer, + src_image, + src_image_layout, + dst_buffer, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_buffer_to_image( + &self, + command_buffer: vk::CommandBuffer, + src_buffer: vk::Buffer, + dst_image: vk::Image, + dst_image_layout: vk::ImageLayout, + regions: &[vk::BufferImageCopy], + ) { + (self.device_fn_1_0.cmd_copy_buffer_to_image)( + command_buffer, + src_buffer, + dst_image, + dst_image_layout, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_image( + &self, + command_buffer: vk::CommandBuffer, + src_image: vk::Image, + src_image_layout: vk::ImageLayout, + dst_image: vk::Image, + dst_image_layout: vk::ImageLayout, + regions: &[vk::ImageCopy], + ) { + (self.device_fn_1_0.cmd_copy_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn allocate_descriptor_sets( + &self, + create_info: &vk::DescriptorSetAllocateInfo, + ) -> VkResult> { + let mut desc_set = Vec::with_capacity(create_info.descriptor_set_count as usize); + (self.device_fn_1_0.allocate_descriptor_sets)( + self.handle(), + create_info, + desc_set.as_mut_ptr(), + ) + .result()?; + + desc_set.set_len(create_info.descriptor_set_count as usize); + Ok(desc_set) + } + + /// + #[inline] + pub unsafe fn create_descriptor_set_layout( + &self, + create_info: &vk::DescriptorSetLayoutCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut layout = mem::zeroed(); + (self.device_fn_1_0.create_descriptor_set_layout)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut layout, + ) + .result_with_success(layout) + } + + /// + #[inline] + pub unsafe fn device_wait_idle(&self) -> VkResult<()> { + (self.device_fn_1_0.device_wait_idle)(self.handle()).result() + } + + /// + #[inline] + pub unsafe fn create_descriptor_pool( + &self, + create_info: &vk::DescriptorPoolCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pool = mem::zeroed(); + (self.device_fn_1_0.create_descriptor_pool)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pool, + ) + .result_with_success(pool) + } + + /// + #[inline] + pub unsafe fn reset_descriptor_pool( + &self, + pool: vk::DescriptorPool, + flags: vk::DescriptorPoolResetFlags, + ) -> VkResult<()> { + (self.device_fn_1_0.reset_descriptor_pool)(self.handle(), pool, flags).result() + } + + /// + #[inline] + pub unsafe fn reset_command_pool( + &self, + command_pool: vk::CommandPool, + flags: vk::CommandPoolResetFlags, + ) -> VkResult<()> { + (self.device_fn_1_0.reset_command_pool)(self.handle(), command_pool, flags).result() + } + + /// + #[inline] + pub unsafe fn reset_command_buffer( + &self, + command_buffer: vk::CommandBuffer, + flags: vk::CommandBufferResetFlags, + ) -> VkResult<()> { + (self.device_fn_1_0.reset_command_buffer)(command_buffer, flags).result() + } + + /// + #[inline] + pub unsafe fn reset_fences(&self, fences: &[vk::Fence]) -> VkResult<()> { + (self.device_fn_1_0.reset_fences)(self.handle(), fences.len() as u32, fences.as_ptr()) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_bind_index_buffer( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + index_type: vk::IndexType, + ) { + (self.device_fn_1_0.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type); + } + + /// + #[inline] + pub unsafe fn cmd_clear_color_image( + &self, + command_buffer: vk::CommandBuffer, + image: vk::Image, + image_layout: vk::ImageLayout, + clear_color_value: &vk::ClearColorValue, + ranges: &[vk::ImageSubresourceRange], + ) { + (self.device_fn_1_0.cmd_clear_color_image)( + command_buffer, + image, + image_layout, + clear_color_value, + ranges.len() as u32, + ranges.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_clear_depth_stencil_image( + &self, + command_buffer: vk::CommandBuffer, + image: vk::Image, + image_layout: vk::ImageLayout, + clear_depth_stencil_value: &vk::ClearDepthStencilValue, + ranges: &[vk::ImageSubresourceRange], + ) { + (self.device_fn_1_0.cmd_clear_depth_stencil_image)( + command_buffer, + image, + image_layout, + clear_depth_stencil_value, + ranges.len() as u32, + ranges.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_clear_attachments( + &self, + command_buffer: vk::CommandBuffer, + attachments: &[vk::ClearAttachment], + rects: &[vk::ClearRect], + ) { + (self.device_fn_1_0.cmd_clear_attachments)( + command_buffer, + attachments.len() as u32, + attachments.as_ptr(), + rects.len() as u32, + rects.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indexed( + &self, + command_buffer: vk::CommandBuffer, + index_count: u32, + instance_count: u32, + first_index: u32, + vertex_offset: i32, + first_instance: u32, + ) { + (self.device_fn_1_0.cmd_draw_indexed)( + command_buffer, + index_count, + instance_count, + first_index, + vertex_offset, + first_instance, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indexed_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + draw_count: u32, + stride: u32, + ) { + (self.device_fn_1_0.cmd_draw_indexed_indirect)( + command_buffer, + buffer, + offset, + draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn cmd_execute_commands( + &self, + primary_command_buffer: vk::CommandBuffer, + secondary_command_buffers: &[vk::CommandBuffer], + ) { + (self.device_fn_1_0.cmd_execute_commands)( + primary_command_buffer, + secondary_command_buffers.len() as u32, + secondary_command_buffers.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_bind_descriptor_sets( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + layout: vk::PipelineLayout, + first_set: u32, + descriptor_sets: &[vk::DescriptorSet], + dynamic_offsets: &[u32], + ) { + (self.device_fn_1_0.cmd_bind_descriptor_sets)( + command_buffer, + pipeline_bind_point, + layout, + first_set, + descriptor_sets.len() as u32, + descriptor_sets.as_ptr(), + dynamic_offsets.len() as u32, + dynamic_offsets.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_query_pool_results( + &self, + command_buffer: vk::CommandBuffer, + query_pool: vk::QueryPool, + first_query: u32, + query_count: u32, + dst_buffer: vk::Buffer, + dst_offset: vk::DeviceSize, + stride: vk::DeviceSize, + flags: vk::QueryResultFlags, + ) { + (self.device_fn_1_0.cmd_copy_query_pool_results)( + command_buffer, + query_pool, + first_query, + query_count, + dst_buffer, + dst_offset, + stride, + flags, + ); + } + + /// + #[inline] + pub unsafe fn cmd_push_constants( + &self, + command_buffer: vk::CommandBuffer, + layout: vk::PipelineLayout, + stage_flags: vk::ShaderStageFlags, + offset: u32, + constants: &[u8], + ) { + (self.device_fn_1_0.cmd_push_constants)( + command_buffer, + layout, + stage_flags, + offset, + constants.len() as _, + constants.as_ptr() as _, + ); + } + + /// + #[inline] + pub unsafe fn cmd_begin_render_pass( + &self, + command_buffer: vk::CommandBuffer, + create_info: &vk::RenderPassBeginInfo, + contents: vk::SubpassContents, + ) { + (self.device_fn_1_0.cmd_begin_render_pass)(command_buffer, create_info, contents); + } + + /// + #[inline] + pub unsafe fn cmd_next_subpass( + &self, + command_buffer: vk::CommandBuffer, + contents: vk::SubpassContents, + ) { + (self.device_fn_1_0.cmd_next_subpass)(command_buffer, contents); + } + + /// + #[inline] + pub unsafe fn cmd_bind_pipeline( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + pipeline: vk::Pipeline, + ) { + (self.device_fn_1_0.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline); + } + + /// + #[inline] + pub unsafe fn cmd_set_scissor( + &self, + command_buffer: vk::CommandBuffer, + first_scissor: u32, + scissors: &[vk::Rect2D], + ) { + (self.device_fn_1_0.cmd_set_scissor)( + command_buffer, + first_scissor, + scissors.len() as u32, + scissors.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_set_line_width(&self, command_buffer: vk::CommandBuffer, line_width: f32) { + (self.device_fn_1_0.cmd_set_line_width)(command_buffer, line_width); + } + + /// + #[inline] + pub unsafe fn cmd_bind_vertex_buffers( + &self, + command_buffer: vk::CommandBuffer, + first_binding: u32, + buffers: &[vk::Buffer], + offsets: &[vk::DeviceSize], + ) { + debug_assert_eq!(buffers.len(), offsets.len()); + (self.device_fn_1_0.cmd_bind_vertex_buffers)( + command_buffer, + first_binding, + buffers.len() as u32, + buffers.as_ptr(), + offsets.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_end_render_pass(&self, command_buffer: vk::CommandBuffer) { + (self.device_fn_1_0.cmd_end_render_pass)(command_buffer); + } + + /// + #[inline] + pub unsafe fn cmd_draw( + &self, + command_buffer: vk::CommandBuffer, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, + ) { + (self.device_fn_1_0.cmd_draw)( + command_buffer, + vertex_count, + instance_count, + first_vertex, + first_instance, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + draw_count: u32, + stride: u32, + ) { + (self.device_fn_1_0.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride); + } + + /// + #[inline] + pub unsafe fn cmd_dispatch( + &self, + command_buffer: vk::CommandBuffer, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, + ) { + (self.device_fn_1_0.cmd_dispatch)( + command_buffer, + group_count_x, + group_count_y, + group_count_z, + ); + } + + /// + #[inline] + pub unsafe fn cmd_dispatch_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + ) { + (self.device_fn_1_0.cmd_dispatch_indirect)(command_buffer, buffer, offset); + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport( + &self, + command_buffer: vk::CommandBuffer, + first_viewport: u32, + viewports: &[vk::Viewport], + ) { + (self.device_fn_1_0.cmd_set_viewport)( + command_buffer, + first_viewport, + viewports.len() as u32, + viewports.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bias( + &self, + command_buffer: vk::CommandBuffer, + constant_factor: f32, + clamp: f32, + slope_factor: f32, + ) { + (self.device_fn_1_0.cmd_set_depth_bias)( + command_buffer, + constant_factor, + clamp, + slope_factor, + ); + } + + /// + #[inline] + pub unsafe fn cmd_set_blend_constants( + &self, + command_buffer: vk::CommandBuffer, + blend_constants: &[f32; 4], + ) { + (self.device_fn_1_0.cmd_set_blend_constants)(command_buffer, blend_constants); + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bounds( + &self, + command_buffer: vk::CommandBuffer, + min_depth_bounds: f32, + max_depth_bounds: f32, + ) { + (self.device_fn_1_0.cmd_set_depth_bounds)( + command_buffer, + min_depth_bounds, + max_depth_bounds, + ); + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_compare_mask( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + compare_mask: u32, + ) { + (self.device_fn_1_0.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask); + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_write_mask( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + write_mask: u32, + ) { + (self.device_fn_1_0.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask); + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_reference( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + reference: u32, + ) { + (self.device_fn_1_0.cmd_set_stencil_reference)(command_buffer, face_mask, reference); + } + + /// + #[inline] + pub unsafe fn get_query_pool_results( + &self, + query_pool: vk::QueryPool, + first_query: u32, + query_count: u32, + data: &mut [T], + flags: vk::QueryResultFlags, + ) -> VkResult<()> { + let data_length = query_count as usize; + assert!( + data_length <= data.len(), + "query_count was higher than the length of the slice" + ); + let data_size = mem::size_of::() * data_length; + (self.device_fn_1_0.get_query_pool_results)( + self.handle(), + query_pool, + first_query, + query_count, + data_size, + data.as_mut_ptr().cast(), + mem::size_of::() as _, + flags, + ) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_begin_query( + &self, + command_buffer: vk::CommandBuffer, + query_pool: vk::QueryPool, + query: u32, + flags: vk::QueryControlFlags, + ) { + (self.device_fn_1_0.cmd_begin_query)(command_buffer, query_pool, query, flags); + } + + /// + #[inline] + pub unsafe fn cmd_end_query( + &self, + command_buffer: vk::CommandBuffer, + query_pool: vk::QueryPool, + query: u32, + ) { + (self.device_fn_1_0.cmd_end_query)(command_buffer, query_pool, query); + } + + /// + #[inline] + pub unsafe fn cmd_reset_query_pool( + &self, + command_buffer: vk::CommandBuffer, + pool: vk::QueryPool, + first_query: u32, + query_count: u32, + ) { + (self.device_fn_1_0.cmd_reset_query_pool)(command_buffer, pool, first_query, query_count); + } + + /// + #[inline] + pub unsafe fn cmd_write_timestamp( + &self, + command_buffer: vk::CommandBuffer, + pipeline_stage: vk::PipelineStageFlags, + query_pool: vk::QueryPool, + query: u32, + ) { + (self.device_fn_1_0.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query); + } + + /// + #[inline] + pub unsafe fn create_semaphore( + &self, + create_info: &vk::SemaphoreCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut semaphore = mem::zeroed(); + (self.device_fn_1_0.create_semaphore)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut semaphore, + ) + .result_with_success(semaphore) + } + + /// + #[inline] + pub unsafe fn create_graphics_pipelines( + &self, + pipeline_cache: vk::PipelineCache, + create_infos: &[vk::GraphicsPipelineCreateInfo], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> Result, (Vec, vk::Result)> { + let mut pipelines = Vec::with_capacity(create_infos.len()); + let err_code = (self.device_fn_1_0.create_graphics_pipelines)( + self.handle(), + pipeline_cache, + create_infos.len() as u32, + create_infos.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ); + pipelines.set_len(create_infos.len()); + match err_code { + vk::Result::SUCCESS => Ok(pipelines), + _ => Err((pipelines, err_code)), + } + } + + /// + #[inline] + pub unsafe fn create_compute_pipelines( + &self, + pipeline_cache: vk::PipelineCache, + create_infos: &[vk::ComputePipelineCreateInfo], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> Result, (Vec, vk::Result)> { + let mut pipelines = Vec::with_capacity(create_infos.len()); + let err_code = (self.device_fn_1_0.create_compute_pipelines)( + self.handle(), + pipeline_cache, + create_infos.len() as u32, + create_infos.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ); + pipelines.set_len(create_infos.len()); + match err_code { + vk::Result::SUCCESS => Ok(pipelines), + _ => Err((pipelines, err_code)), + } + } + + /// + #[inline] + pub unsafe fn create_buffer( + &self, + create_info: &vk::BufferCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut buffer = mem::zeroed(); + (self.device_fn_1_0.create_buffer)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut buffer, + ) + .result_with_success(buffer) + } + + /// + #[inline] + pub unsafe fn create_pipeline_layout( + &self, + create_info: &vk::PipelineLayoutCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pipeline_layout = mem::zeroed(); + (self.device_fn_1_0.create_pipeline_layout)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pipeline_layout, + ) + .result_with_success(pipeline_layout) + } + + /// + #[inline] + pub unsafe fn create_pipeline_cache( + &self, + create_info: &vk::PipelineCacheCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pipeline_cache = mem::zeroed(); + (self.device_fn_1_0.create_pipeline_cache)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pipeline_cache, + ) + .result_with_success(pipeline_cache) + } + + /// + #[inline] + pub unsafe fn get_pipeline_cache_data( + &self, + pipeline_cache: vk::PipelineCache, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.device_fn_1_0.get_pipeline_cache_data)( + self.handle(), + pipeline_cache, + count, + data as _, + ) + }) + } + + /// + #[inline] + pub unsafe fn merge_pipeline_caches( + &self, + dst_cache: vk::PipelineCache, + src_caches: &[vk::PipelineCache], + ) -> VkResult<()> { + (self.device_fn_1_0.merge_pipeline_caches)( + self.handle(), + dst_cache, + src_caches.len() as u32, + src_caches.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn map_memory( + &self, + memory: vk::DeviceMemory, + offset: vk::DeviceSize, + size: vk::DeviceSize, + flags: vk::MemoryMapFlags, + ) -> VkResult<*mut c_void> { + let mut data: *mut c_void = ptr::null_mut(); + (self.device_fn_1_0.map_memory)(self.handle(), memory, offset, size, flags, &mut data) + .result_with_success(data) + } + + /// + #[inline] + pub unsafe fn unmap_memory(&self, memory: vk::DeviceMemory) { + (self.device_fn_1_0.unmap_memory)(self.handle(), memory); + } + + /// + #[inline] + pub unsafe fn invalidate_mapped_memory_ranges( + &self, + ranges: &[vk::MappedMemoryRange], + ) -> VkResult<()> { + (self.device_fn_1_0.invalidate_mapped_memory_ranges)( + self.handle(), + ranges.len() as u32, + ranges.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn flush_mapped_memory_ranges( + &self, + ranges: &[vk::MappedMemoryRange], + ) -> VkResult<()> { + (self.device_fn_1_0.flush_mapped_memory_ranges)( + self.handle(), + ranges.len() as u32, + ranges.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn create_framebuffer( + &self, + create_info: &vk::FramebufferCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut framebuffer = mem::zeroed(); + (self.device_fn_1_0.create_framebuffer)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut framebuffer, + ) + .result_with_success(framebuffer) + } + + /// + #[inline] + pub unsafe fn get_device_queue(&self, queue_family_index: u32, queue_index: u32) -> vk::Queue { + let mut queue = mem::zeroed(); + (self.device_fn_1_0.get_device_queue)( + self.handle(), + queue_family_index, + queue_index, + &mut queue, + ); + queue + } + + /// + #[inline] + pub unsafe fn cmd_pipeline_barrier( + &self, + command_buffer: vk::CommandBuffer, + src_stage_mask: vk::PipelineStageFlags, + dst_stage_mask: vk::PipelineStageFlags, + dependency_flags: vk::DependencyFlags, + memory_barriers: &[vk::MemoryBarrier], + buffer_memory_barriers: &[vk::BufferMemoryBarrier], + image_memory_barriers: &[vk::ImageMemoryBarrier], + ) { + (self.device_fn_1_0.cmd_pipeline_barrier)( + command_buffer, + src_stage_mask, + dst_stage_mask, + dependency_flags, + memory_barriers.len() as u32, + memory_barriers.as_ptr(), + buffer_memory_barriers.len() as u32, + buffer_memory_barriers.as_ptr(), + image_memory_barriers.len() as u32, + image_memory_barriers.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_render_pass( + &self, + create_info: &vk::RenderPassCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut renderpass = mem::zeroed(); + (self.device_fn_1_0.create_render_pass)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut renderpass, + ) + .result_with_success(renderpass) + } + + /// + #[inline] + pub unsafe fn begin_command_buffer( + &self, + command_buffer: vk::CommandBuffer, + begin_info: &vk::CommandBufferBeginInfo, + ) -> VkResult<()> { + (self.device_fn_1_0.begin_command_buffer)(command_buffer, begin_info).result() + } + + /// + #[inline] + pub unsafe fn end_command_buffer(&self, command_buffer: vk::CommandBuffer) -> VkResult<()> { + (self.device_fn_1_0.end_command_buffer)(command_buffer).result() + } + + /// + #[inline] + pub unsafe fn wait_for_fences( + &self, + fences: &[vk::Fence], + wait_all: bool, + timeout: u64, + ) -> VkResult<()> { + (self.device_fn_1_0.wait_for_fences)( + self.handle(), + fences.len() as u32, + fences.as_ptr(), + wait_all as u32, + timeout, + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_fence_status(&self, fence: vk::Fence) -> VkResult { + let err_code = (self.device_fn_1_0.get_fence_status)(self.handle(), fence); + match err_code { + vk::Result::SUCCESS => Ok(true), + vk::Result::NOT_READY => Ok(false), + _ => Err(err_code), + } + } + + /// + #[inline] + pub unsafe fn queue_wait_idle(&self, queue: vk::Queue) -> VkResult<()> { + (self.device_fn_1_0.queue_wait_idle)(queue).result() + } + + /// + #[inline] + pub unsafe fn queue_submit( + &self, + queue: vk::Queue, + submits: &[vk::SubmitInfo], + fence: vk::Fence, + ) -> VkResult<()> { + (self.device_fn_1_0.queue_submit)(queue, submits.len() as u32, submits.as_ptr(), fence) + .result() + } + + /// + #[inline] + pub unsafe fn queue_bind_sparse( + &self, + queue: vk::Queue, + bind_info: &[vk::BindSparseInfo], + fence: vk::Fence, + ) -> VkResult<()> { + (self.device_fn_1_0.queue_bind_sparse)( + queue, + bind_info.len() as u32, + bind_info.as_ptr(), + fence, + ) + .result() + } + + /// + #[inline] + pub unsafe fn create_buffer_view( + &self, + create_info: &vk::BufferViewCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut buffer_view = mem::zeroed(); + (self.device_fn_1_0.create_buffer_view)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut buffer_view, + ) + .result_with_success(buffer_view) + } + + /// + #[inline] + pub unsafe fn destroy_buffer_view( + &self, + buffer_view: vk::BufferView, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_buffer_view)( + self.handle(), + buffer_view, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_image_view( + &self, + create_info: &vk::ImageViewCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut image_view = mem::zeroed(); + (self.device_fn_1_0.create_image_view)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut image_view, + ) + .result_with_success(image_view) + } + + /// + #[inline] + pub unsafe fn allocate_command_buffers( + &self, + create_info: &vk::CommandBufferAllocateInfo, + ) -> VkResult> { + let mut buffers = Vec::with_capacity(create_info.command_buffer_count as usize); + (self.device_fn_1_0.allocate_command_buffers)( + self.handle(), + create_info, + buffers.as_mut_ptr(), + ) + .result()?; + buffers.set_len(create_info.command_buffer_count as usize); + Ok(buffers) + } + + /// + #[inline] + pub unsafe fn create_command_pool( + &self, + create_info: &vk::CommandPoolCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pool = mem::zeroed(); + (self.device_fn_1_0.create_command_pool)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pool, + ) + .result_with_success(pool) + } + + /// + #[inline] + pub unsafe fn create_query_pool( + &self, + create_info: &vk::QueryPoolCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pool = mem::zeroed(); + (self.device_fn_1_0.create_query_pool)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pool, + ) + .result_with_success(pool) + } + + /// + #[inline] + pub unsafe fn create_image( + &self, + create_info: &vk::ImageCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut image = mem::zeroed(); + (self.device_fn_1_0.create_image)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut image, + ) + .result_with_success(image) + } + + /// + #[inline] + pub unsafe fn get_image_subresource_layout( + &self, + image: vk::Image, + subresource: vk::ImageSubresource, + ) -> vk::SubresourceLayout { + let mut layout = mem::zeroed(); + (self.device_fn_1_0.get_image_subresource_layout)( + self.handle(), + image, + &subresource, + &mut layout, + ); + layout + } + + /// + #[inline] + pub unsafe fn get_image_memory_requirements(&self, image: vk::Image) -> vk::MemoryRequirements { + let mut mem_req = mem::zeroed(); + (self.device_fn_1_0.get_image_memory_requirements)(self.handle(), image, &mut mem_req); + mem_req + } + + /// + #[inline] + pub unsafe fn get_buffer_memory_requirements( + &self, + buffer: vk::Buffer, + ) -> vk::MemoryRequirements { + let mut mem_req = mem::zeroed(); + (self.device_fn_1_0.get_buffer_memory_requirements)(self.handle(), buffer, &mut mem_req); + mem_req + } + + /// + #[inline] + pub unsafe fn allocate_memory( + &self, + create_info: &vk::MemoryAllocateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut memory = mem::zeroed(); + (self.device_fn_1_0.allocate_memory)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut memory, + ) + .result_with_success(memory) + } + + /// + #[inline] + pub unsafe fn create_shader_module( + &self, + create_info: &vk::ShaderModuleCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut shader = mem::zeroed(); + (self.device_fn_1_0.create_shader_module)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut shader, + ) + .result_with_success(shader) + } + + /// + #[inline] + pub unsafe fn create_fence( + &self, + create_info: &vk::FenceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut fence = mem::zeroed(); + (self.device_fn_1_0.create_fence)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut fence, + ) + .result_with_success(fence) + } + + /// + #[inline] + pub unsafe fn bind_buffer_memory( + &self, + buffer: vk::Buffer, + device_memory: vk::DeviceMemory, + offset: vk::DeviceSize, + ) -> VkResult<()> { + (self.device_fn_1_0.bind_buffer_memory)(self.handle(), buffer, device_memory, offset) + .result() + } + + /// + #[inline] + pub unsafe fn bind_image_memory( + &self, + image: vk::Image, + device_memory: vk::DeviceMemory, + offset: vk::DeviceSize, + ) -> VkResult<()> { + (self.device_fn_1_0.bind_image_memory)(self.handle(), image, device_memory, offset).result() + } + + /// + #[inline] + pub unsafe fn get_render_area_granularity(&self, render_pass: vk::RenderPass) -> vk::Extent2D { + let mut granularity = mem::zeroed(); + (self.device_fn_1_0.get_render_area_granularity)( + self.handle(), + render_pass, + &mut granularity, + ); + granularity + } + + /// + #[inline] + pub unsafe fn get_device_memory_commitment(&self, memory: vk::DeviceMemory) -> vk::DeviceSize { + let mut committed_memory_in_bytes = 0; + (self.device_fn_1_0.get_device_memory_commitment)( + self.handle(), + memory, + &mut committed_memory_in_bytes, + ); + committed_memory_in_bytes + } + + /// + #[inline] + pub unsafe fn get_image_sparse_memory_requirements( + &self, + image: vk::Image, + ) -> Vec { + read_into_uninitialized_vector(|count, data| { + (self.device_fn_1_0.get_image_sparse_memory_requirements)( + self.handle(), + image, + count, + data, + ); + vk::Result::SUCCESS + }) + // The closure always returns SUCCESS + .unwrap() + } +} diff --git a/third_party/rust/ash/src/entry.rs b/third_party/rust/ash/src/entry.rs new file mode 100644 index 0000000000..67e6c9a739 --- /dev/null +++ b/third_party/rust/ash/src/entry.rs @@ -0,0 +1,402 @@ +use crate::instance::Instance; +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use std::ffi::CStr; +#[cfg(feature = "loaded")] +use std::ffi::OsStr; +use std::mem; +use std::os::raw::c_char; +use std::os::raw::c_void; +use std::ptr; +#[cfg(feature = "loaded")] +use std::sync::Arc; + +#[cfg(feature = "loaded")] +use libloading::Library; + +/// Holds the Vulkan functions independent of a particular instance +#[derive(Clone)] +pub struct Entry { + static_fn: vk::StaticFn, + entry_fn_1_0: vk::EntryFnV1_0, + entry_fn_1_1: vk::EntryFnV1_1, + entry_fn_1_2: vk::EntryFnV1_2, + entry_fn_1_3: vk::EntryFnV1_3, + #[cfg(feature = "loaded")] + _lib_guard: Option>, +} + +/// Vulkan core 1.0 +#[allow(non_camel_case_types)] +impl Entry { + /// Load default Vulkan library for the current platform + /// + /// Prefer this over [`linked`](Self::linked) when your application can gracefully handle + /// environments that lack Vulkan support, and when the build environment might not have Vulkan + /// development packages installed (e.g. the Vulkan SDK, or Ubuntu's `libvulkan-dev`). + /// + /// # Safety + /// `dlopen`ing native libraries is inherently unsafe. The safety guidelines + /// for [`Library::new()`] and [`Library::get()`] apply here. + /// + /// ```no_run + /// use ash::{vk, Entry}; + /// # fn main() -> Result<(), Box> { + /// let entry = unsafe { Entry::load()? }; + /// let app_info = vk::ApplicationInfo { + /// api_version: vk::make_api_version(0, 1, 0, 0), + /// ..Default::default() + /// }; + /// let create_info = vk::InstanceCreateInfo { + /// p_application_info: &app_info, + /// ..Default::default() + /// }; + /// let instance = unsafe { entry.create_instance(&create_info, None)? }; + /// # Ok(()) } + /// ``` + #[cfg(feature = "loaded")] + #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))] + pub unsafe fn load() -> Result { + #[cfg(windows)] + const LIB_PATH: &str = "vulkan-1.dll"; + + #[cfg(all( + unix, + not(any(target_os = "macos", target_os = "ios", target_os = "android")) + ))] + const LIB_PATH: &str = "libvulkan.so.1"; + + #[cfg(target_os = "android")] + const LIB_PATH: &str = "libvulkan.so"; + + #[cfg(any(target_os = "macos", target_os = "ios"))] + const LIB_PATH: &str = "libvulkan.dylib"; + + Self::load_from(LIB_PATH) + } + + /// Load entry points from a Vulkan loader linked at compile time + /// + /// Compared to [`load`](Self::load), this is infallible, but requires that the build + /// environment have Vulkan development packages installed (e.g. the Vulkan SDK, or Ubuntu's + /// `libvulkan-dev`), and prevents the resulting binary from starting in environments that do not + /// support Vulkan. + /// + /// Note that instance/device functions are still fetched via `vkGetInstanceProcAddr` and + /// `vkGetDeviceProcAddr` for maximum performance. + /// + /// ```no_run + /// use ash::{vk, Entry}; + /// # fn main() -> Result<(), Box> { + /// let entry = Entry::linked(); + /// let app_info = vk::ApplicationInfo { + /// api_version: vk::make_api_version(0, 1, 0, 0), + /// ..Default::default() + /// }; + /// let create_info = vk::InstanceCreateInfo { + /// p_application_info: &app_info, + /// ..Default::default() + /// }; + /// let instance = unsafe { entry.create_instance(&create_info, None)? }; + /// # Ok(()) } + /// ``` + #[cfg(feature = "linked")] + #[cfg_attr(docsrs, doc(cfg(feature = "linked")))] + pub fn linked() -> Self { + // Sound because we're linking to Vulkan, which provides a vkGetInstanceProcAddr that has + // defined behavior in this use. + unsafe { + Self::from_static_fn(vk::StaticFn { + get_instance_proc_addr: vkGetInstanceProcAddr, + }) + } + } + + /// Load Vulkan library at `path` + /// + /// # Safety + /// `dlopen`ing native libraries is inherently unsafe. The safety guidelines + /// for [`Library::new()`] and [`Library::get()`] apply here. + #[cfg(feature = "loaded")] + #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))] + pub unsafe fn load_from(path: impl AsRef) -> Result { + let lib = Library::new(path) + .map_err(LoadingError::LibraryLoadFailure) + .map(Arc::new)?; + + let static_fn = vk::StaticFn::load_checked(|name| { + lib.get(name.to_bytes_with_nul()) + .map(|symbol| *symbol) + .unwrap_or(ptr::null_mut()) + })?; + + Ok(Self { + _lib_guard: Some(lib), + ..Self::from_static_fn(static_fn) + }) + } + + /// Load entry points based on an already-loaded [`vk::StaticFn`] + /// + /// # Safety + /// `static_fn` must contain valid function pointers that comply with the semantics specified by + /// Vulkan 1.0, which must remain valid for at least the lifetime of the returned [`Entry`]. + pub unsafe fn from_static_fn(static_fn: vk::StaticFn) -> Self { + let load_fn = |name: &std::ffi::CStr| { + mem::transmute((static_fn.get_instance_proc_addr)( + vk::Instance::null(), + name.as_ptr(), + )) + }; + let entry_fn_1_0 = vk::EntryFnV1_0::load(load_fn); + let entry_fn_1_1 = vk::EntryFnV1_1::load(load_fn); + let entry_fn_1_2 = vk::EntryFnV1_2::load(load_fn); + let entry_fn_1_3 = vk::EntryFnV1_3::load(load_fn); + + Self { + static_fn, + entry_fn_1_0, + entry_fn_1_1, + entry_fn_1_2, + entry_fn_1_3, + #[cfg(feature = "loaded")] + _lib_guard: None, + } + } + + #[inline] + pub fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { + &self.entry_fn_1_0 + } + + #[inline] + pub fn static_fn(&self) -> &vk::StaticFn { + &self.static_fn + } + + /// + /// ```no_run + /// # use ash::{Entry, vk}; + /// # fn main() -> Result<(), Box> { + /// let entry = Entry::linked(); + /// match entry.try_enumerate_instance_version()? { + /// // Vulkan 1.1+ + /// Some(version) => { + /// let major = vk::version_major(version); + /// let minor = vk::version_minor(version); + /// let patch = vk::version_patch(version); + /// }, + /// // Vulkan 1.0 + /// None => {}, + /// } + /// # Ok(()) } + /// ``` + #[inline] + pub fn try_enumerate_instance_version(&self) -> VkResult> { + unsafe { + let mut api_version = 0; + let enumerate_instance_version: Option = { + let name = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateInstanceVersion\0", + ); + mem::transmute((self.static_fn.get_instance_proc_addr)( + vk::Instance::null(), + name.as_ptr(), + )) + }; + if let Some(enumerate_instance_version) = enumerate_instance_version { + (enumerate_instance_version)(&mut api_version) + .result_with_success(Some(api_version)) + } else { + Ok(None) + } + } + } + + /// + /// + /// # Safety + /// In order for the created [`Instance`] to be valid for the duration of its + /// usage, the [`Entry`](Self) this was called on must be dropped later than the + /// resulting [`Instance`]. + #[inline] + pub unsafe fn create_instance( + &self, + create_info: &vk::InstanceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut instance = mem::zeroed(); + (self.entry_fn_1_0.create_instance)( + create_info, + allocation_callbacks.as_raw_ptr(), + &mut instance, + ) + .result()?; + Ok(Instance::load(&self.static_fn, instance)) + } + + /// + #[inline] + pub fn enumerate_instance_layer_properties(&self) -> VkResult> { + unsafe { + read_into_uninitialized_vector(|count, data| { + (self.entry_fn_1_0.enumerate_instance_layer_properties)(count, data) + }) + } + } + + /// + #[inline] + pub fn enumerate_instance_extension_properties( + &self, + layer_name: Option<&CStr>, + ) -> VkResult> { + unsafe { + read_into_uninitialized_vector(|count, data| { + (self.entry_fn_1_0.enumerate_instance_extension_properties)( + layer_name.map_or(ptr::null(), |str| str.as_ptr()), + count, + data, + ) + }) + } + } + + /// + #[inline] + pub unsafe fn get_instance_proc_addr( + &self, + instance: vk::Instance, + p_name: *const c_char, + ) -> vk::PFN_vkVoidFunction { + (self.static_fn.get_instance_proc_addr)(instance, p_name) + } +} + +/// Vulkan core 1.1 +#[allow(non_camel_case_types)] +impl Entry { + #[inline] + pub fn fp_v1_1(&self) -> &vk::EntryFnV1_1 { + &self.entry_fn_1_1 + } + + #[deprecated = "This function is unavailable and therefore panics on Vulkan 1.0, please use `try_enumerate_instance_version()` instead"] + /// + /// + /// Please use [`try_enumerate_instance_version()`][Self::try_enumerate_instance_version()] instead. + #[inline] + pub fn enumerate_instance_version(&self) -> VkResult { + unsafe { + let mut api_version = 0; + (self.entry_fn_1_1.enumerate_instance_version)(&mut api_version) + .result_with_success(api_version) + } + } +} + +/// Vulkan core 1.2 +#[allow(non_camel_case_types)] +impl Entry { + #[inline] + pub fn fp_v1_2(&self) -> &vk::EntryFnV1_2 { + &self.entry_fn_1_2 + } +} + +/// Vulkan core 1.3 +#[allow(non_camel_case_types)] +impl Entry { + #[inline] + pub fn fp_v1_3(&self) -> &vk::EntryFnV1_3 { + &self.entry_fn_1_3 + } +} + +#[cfg(feature = "linked")] +#[cfg_attr(docsrs, doc(cfg(feature = "linked")))] +impl Default for Entry { + #[inline] + fn default() -> Self { + Self::linked() + } +} + +impl vk::StaticFn { + pub fn load_checked(mut _f: F) -> Result + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + // TODO: Make this a &'static CStr once CStr::from_bytes_with_nul_unchecked is const + static ENTRY_POINT: &[u8] = b"vkGetInstanceProcAddr\0"; + + Ok(Self { + get_instance_proc_addr: unsafe { + let cname = CStr::from_bytes_with_nul_unchecked(ENTRY_POINT); + let val = _f(cname); + if val.is_null() { + return Err(MissingEntryPoint); + } else { + ::std::mem::transmute(val) + } + }, + }) + } +} + +#[derive(Clone, Debug)] +pub struct MissingEntryPoint; +impl std::fmt::Display for MissingEntryPoint { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> { + write!(f, "Cannot load `vkGetInstanceProcAddr` symbol from library") + } +} +impl std::error::Error for MissingEntryPoint {} + +#[cfg(feature = "linked")] +extern "system" { + fn vkGetInstanceProcAddr(instance: vk::Instance, name: *const c_char) + -> vk::PFN_vkVoidFunction; +} + +#[cfg(feature = "loaded")] +mod loaded { + use std::error::Error; + use std::fmt; + + use super::*; + + #[derive(Debug)] + #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))] + pub enum LoadingError { + LibraryLoadFailure(libloading::Error), + MissingEntryPoint(MissingEntryPoint), + } + + impl fmt::Display for LoadingError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Self::LibraryLoadFailure(err) => fmt::Display::fmt(err, f), + Self::MissingEntryPoint(err) => fmt::Display::fmt(err, f), + } + } + } + + impl Error for LoadingError { + fn source(&self) -> Option<&(dyn Error + 'static)> { + Some(match self { + Self::LibraryLoadFailure(err) => err, + Self::MissingEntryPoint(err) => err, + }) + } + } + + impl From for LoadingError { + fn from(err: MissingEntryPoint) -> Self { + Self::MissingEntryPoint(err) + } + } +} +#[cfg(feature = "loaded")] +pub use self::loaded::*; diff --git a/third_party/rust/ash/src/extensions/experimental/amd.rs b/third_party/rust/ash/src/extensions/experimental/amd.rs new file mode 100644 index 0000000000..35b4289f16 --- /dev/null +++ b/third_party/rust/ash/src/extensions/experimental/amd.rs @@ -0,0 +1,722 @@ +#![allow(clippy::unreadable_literal)] + +/* + *********************************************************************************************************************** + * + * Copyright (c) 2014-2019 Advanced Micro Devices, Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + **********************************************************************************************************************/ + +#[cfg(feature = "debug")] +use crate::prelude::debug_flags; +use crate::vk::*; + +use std::fmt; +use std::os::raw::*; + +// Extension: `VK_AMD_gpa_interface` + +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct GpaSqShaderStageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(GpaSqShaderStageFlags, Flags); +#[cfg(feature = "debug")] +impl fmt::Debug for GpaSqShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GpaSqShaderStageFlags::PS.0, "PS"), + (GpaSqShaderStageFlags::VS.0, "VS"), + (GpaSqShaderStageFlags::GS.0, "GS"), + (GpaSqShaderStageFlags::ES.0, "ES"), + (GpaSqShaderStageFlags::HS.0, "HS"), + (GpaSqShaderStageFlags::LS.0, "LS"), + (GpaSqShaderStageFlags::CS.0, "CS"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl GpaSqShaderStageFlags { + pub const PS: Self = Self(0b1); + pub const VS: Self = Self(0b10); + pub const GS: Self = Self(0b100); + pub const ES: Self = Self(0b1000); + pub const HS: Self = Self(0b10000); + pub const LS: Self = Self(0b100000); + pub const CS: Self = Self(0b1000000); +} + +impl StructureType { + pub const PHYSICAL_DEVICE_GPA_FEATURES_AMD: Self = Self(1000133000); + pub const PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: Self = Self(1000133001); + pub const GPA_SAMPLE_BEGIN_INFO_AMD: Self = Self(1000133002); + pub const GPA_SESSION_CREATE_INFO_AMD: Self = Self(1000133003); + pub const GPA_DEVICE_CLOCK_MODE_INFO_AMD: Self = Self(1000133004); +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[repr(transparent)] +pub struct GpaDeviceClockModeAmd(pub(crate) i32); +impl GpaDeviceClockModeAmd { + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} +impl GpaDeviceClockModeAmd { + pub const DEFAULT: Self = Self(0); + pub const QUERY: Self = Self(1); + pub const PROFILING: Self = Self(2); + pub const MIN_MEMORY: Self = Self(3); + pub const MIN_ENGINE: Self = Self(4); + pub const PEAK: Self = Self(5); +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[repr(transparent)] +pub struct GpaPerfBlockAmd(pub(crate) i32); +impl GpaPerfBlockAmd { + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} +impl GpaPerfBlockAmd { + pub const CPF: Self = Self(0); + pub const IA: Self = Self(1); + pub const VGT: Self = Self(2); + pub const PA: Self = Self(3); + pub const SC: Self = Self(4); + pub const SPI: Self = Self(5); + pub const SQ: Self = Self(6); + pub const SX: Self = Self(7); + pub const TA: Self = Self(8); + pub const TD: Self = Self(9); + pub const TCP: Self = Self(10); + pub const TCC: Self = Self(11); + pub const TCA: Self = Self(12); + pub const DB: Self = Self(13); + pub const CB: Self = Self(14); + pub const GDS: Self = Self(15); + pub const SRBM: Self = Self(16); + pub const GRBM: Self = Self(17); + pub const GRBM_SE: Self = Self(18); + pub const RLC: Self = Self(19); + pub const DMA: Self = Self(20); + pub const MC: Self = Self(21); + pub const CPG: Self = Self(22); + pub const CPC: Self = Self(23); + pub const WD: Self = Self(24); + pub const TCS: Self = Self(25); + pub const ATC: Self = Self(26); + pub const ATC_L2: Self = Self(27); + pub const MC_VM_L2: Self = Self(28); + pub const EA: Self = Self(29); + pub const RPB: Self = Self(30); + pub const RMI: Self = Self(31); +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[repr(transparent)] +pub struct GpaSampleTypeAmd(pub(crate) i32); +impl GpaSampleTypeAmd { + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} +impl GpaSampleTypeAmd { + pub const CUMULATIVE: Self = Self(0); + pub const TRACE: Self = Self(1); + pub const TIMING: Self = Self(2); +} + +handle_nondispatchable!(GpaSessionAmd, UNKNOWN); + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaSessionCreateInfoAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub secondary_copy_source: GpaSessionAmd, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaPerfBlockPropertiesAmd { + pub block_type: GpaPerfBlockAmd, + pub flags: Flags, + pub instance_count: u32, + pub max_event_id: u32, + pub max_global_only_counters: u32, + pub max_global_shared_counters: u32, + pub max_streaming_counters: u32, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct PhysicalDeviceGpaFeaturesAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub perf_counters: Bool32, + pub streaming_perf_counters: Bool32, + pub sq_thread_tracing: Bool32, + pub clock_modes: Bool32, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct PhysicalDeviceGpaPropertiesAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: Flags, + pub max_sqtt_se_buffer_size: DeviceSize, + pub shader_engine_count: u32, + pub perf_block_count: u32, + pub p_perf_block_properties: *mut GpaPerfBlockPropertiesAmd, +} + +impl ::std::default::Default for PhysicalDeviceGpaPropertiesAmd { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_GPA_PROPERTIES_AMD, + p_next: ::std::ptr::null_mut(), + flags: Flags::default(), + max_sqtt_se_buffer_size: DeviceSize::default(), + shader_engine_count: u32::default(), + perf_block_count: u32::default(), + p_perf_block_properties: ::std::ptr::null_mut(), + } + } +} +impl PhysicalDeviceGpaPropertiesAmd { + pub fn builder<'a>() -> PhysicalDeviceGpaPropertiesAmdBuilder<'a> { + PhysicalDeviceGpaPropertiesAmdBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceGpaPropertiesAmdBuilder<'a> { + inner: PhysicalDeviceGpaPropertiesAmd, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceGpaPropertiesAmd {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceGpaPropertiesAmd {} +impl<'a> ::std::ops::Deref for PhysicalDeviceGpaPropertiesAmdBuilder<'a> { + type Target = PhysicalDeviceGpaPropertiesAmd; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceGpaPropertiesAmdBuilder<'a> { + pub fn push_next(mut self, next: &'a mut T) -> PhysicalDeviceGpaPropertiesAmdBuilder<'a> + where + T: ExtendsPhysicalDeviceGpaPropertiesAmd, + { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + pub fn build(self) -> PhysicalDeviceGpaPropertiesAmd { + self.inner + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaPerfCounterAmd { + pub block_type: GpaPerfBlockAmd, + pub block_instance: u32, + pub event_id: u32, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaSampleBeginInfoAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_type: GpaSampleTypeAmd, + pub sample_internal_operations: Bool32, + pub cache_flush_on_counter_collection: Bool32, + pub sq_shader_mask_enable: Bool32, + pub sq_shader_mask: GpaSqShaderStageFlags, + pub perf_counter_count: u32, + pub p_perf_counters: *const GpaPerfCounterAmd, + pub streaming_perf_trace_sample_interval: u32, + pub perf_counter_device_memory_limit: DeviceSize, + pub sq_thread_trace_enable: Bool32, + pub sq_thread_trace_suppress_instruction_tokens: Bool32, + pub sq_thread_trace_device_memory_limit: DeviceSize, + pub timing_pre_sample: PipelineStageFlags, + pub timing_post_sample: PipelineStageFlags, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaDeviceClockModeInfoAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub clock_mode: GpaDeviceClockModeAmd, + pub memory_clock_ratio_to_peak: f32, + pub engine_clock_ratio_to_peak: f32, +} + +#[allow(non_camel_case_types)] +pub type PFN_vkCreateGpaSessionAMD = extern "system" fn( + device: Device, + p_create_info: *const GpaSessionCreateInfoAmd, + p_allocator: *const AllocationCallbacks, + p_gpa_session: *mut GpaSessionAmd, +) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyGpaSessionAMD = extern "system" fn( + device: Device, + gpa_session: GpaSessionAmd, + p_allocator: *const AllocationCallbacks, +) -> c_void; + +#[allow(non_camel_case_types)] +pub type PFN_vkSetGpaDeviceClockModeAMD = + extern "system" fn(device: Device, p_info: *mut GpaDeviceClockModeInfoAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginGpaSessionAMD = + extern "system" fn(commandBuffer: CommandBuffer, gpa_session: GpaSessionAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndGpaSessionAMD = + extern "system" fn(commandBuffer: CommandBuffer, gpa_session: GpaSessionAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginGpaSampleAMD = extern "system" fn( + commandBuffer: CommandBuffer, + gpa_session: GpaSessionAmd, + p_gpa_sample_begin_info: *const GpaSampleBeginInfoAmd, + p_sample_id: *mut u32, +) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndGpaSampleAMD = extern "system" fn( + commandBuffer: CommandBuffer, + gpa_session: GpaSessionAmd, + sample_id: u32, +) -> c_void; + +#[allow(non_camel_case_types)] +pub type PFN_vkGetGpaSessionStatusAMD = + extern "system" fn(device: Device, gpaSession: GpaSessionAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkGetGpaSessionResultsAMD = extern "system" fn( + device: Device, + gpaSession: GpaSessionAmd, + sample_id: u32, + p_size_in_bytes: *mut usize, + p_data: *mut c_void, +) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkResetGpaSessionAMD = + extern "system" fn(device: Device, gpaSession: GpaSessionAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyGpaSessionResultsAMD = + extern "system" fn(commandBuffer: CommandBuffer, gpaSession: GpaSessionAmd) -> c_void; + +pub struct AmdGpaInterfaceFn { + pub create_gpa_session: PFN_vkCreateGpaSessionAMD, + pub destroy_gpa_session: PFN_vkDestroyGpaSessionAMD, + pub set_gpa_device_clock_mode: PFN_vkSetGpaDeviceClockModeAMD, + pub cmd_begin_gpa_session: PFN_vkCmdBeginGpaSessionAMD, + pub cmd_end_gpa_session: PFN_vkCmdEndGpaSessionAMD, + pub cmd_begin_gpa_sample: PFN_vkCmdBeginGpaSampleAMD, + pub cmd_end_gpa_sample: PFN_vkCmdEndGpaSampleAMD, + pub get_gpa_session_status: PFN_vkGetGpaSessionStatusAMD, + pub get_gpa_session_results: PFN_vkGetGpaSessionResultsAMD, + pub reset_gpa_session: PFN_vkResetGpaSessionAMD, + pub cmd_copy_gpa_session_results: PFN_vkCmdCopyGpaSessionResultsAMD, +} +unsafe impl Send for AmdGpaInterfaceFn {} +unsafe impl Sync for AmdGpaInterfaceFn {} + +impl ::std::clone::Clone for AmdGpaInterfaceFn { + fn clone(&self) -> Self { + Self { + create_gpa_session: self.create_gpa_session, + destroy_gpa_session: self.destroy_gpa_session, + set_gpa_device_clock_mode: self.set_gpa_device_clock_mode, + cmd_begin_gpa_session: self.cmd_begin_gpa_session, + cmd_end_gpa_session: self.cmd_end_gpa_session, + cmd_begin_gpa_sample: self.cmd_begin_gpa_sample, + cmd_end_gpa_sample: self.cmd_end_gpa_sample, + get_gpa_session_status: self.get_gpa_session_status, + get_gpa_session_results: self.get_gpa_session_results, + reset_gpa_session: self.reset_gpa_session, + cmd_copy_gpa_session_results: self.cmd_copy_gpa_session_results, + } + } +} + +impl AmdGpaInterfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_gpa_session: unsafe { + extern "system" fn create_gpa_session_amd( + _device: Device, + _p_create_info: *const GpaSessionCreateInfoAmd, + _p_allocator: *const AllocationCallbacks, + _p_gpa_session: *mut GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + create_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + destroy_gpa_session: unsafe { + extern "system" fn destroy_gpa_session_amd( + _device: Device, + _gpa_session: GpaSessionAmd, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + destroy_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + set_gpa_device_clock_mode: unsafe { + extern "system" fn set_gpa_device_clock_mode_amd( + _device: Device, + _p_info: *mut GpaDeviceClockModeInfoAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_gpa_device_clock_mode_amd) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetGpaDeviceClockModeAMD\0", + ); + let val = _f(cname); + if val.is_null() { + set_gpa_device_clock_mode_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_gpa_session: unsafe { + extern "system" fn cmd_begin_gpa_session_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_gpa_session: unsafe { + extern "system" fn cmd_end_gpa_session_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_gpa_sample: unsafe { + extern "system" fn cmd_begin_gpa_sample_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + _p_gpa_sample_begin_info: *const GpaSampleBeginInfoAmd, + _p_sample_id: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_gpa_sample_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginGpaSampleAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_gpa_sample_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_gpa_sample: unsafe { + extern "system" fn cmd_end_gpa_sample_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + _sample_id: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_gpa_sample_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSampleAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_gpa_sample_amd + } else { + ::std::mem::transmute(val) + } + }, + get_gpa_session_status: unsafe { + extern "system" fn get_gpa_session_status_amd( + _device: Device, + _gpa_session: GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_gpa_session_status_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetGpaSessionStatusAMD\0"); + let val = _f(cname); + if val.is_null() { + get_gpa_session_status_amd + } else { + ::std::mem::transmute(val) + } + }, + get_gpa_session_results: unsafe { + extern "system" fn get_gpa_session_results_amd( + _device: Device, + _gpa_session: GpaSessionAmd, + _sample_id: u32, + _p_size_in_bytes: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_gpa_session_results_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetGpaSessionResultsAMD\0"); + let val = _f(cname); + if val.is_null() { + get_gpa_session_results_amd + } else { + ::std::mem::transmute(val) + } + }, + reset_gpa_session: unsafe { + extern "system" fn reset_gpa_session_amd( + _device: Device, + _gpa_session: GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(reset_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSampleAMD\0"); + let val = _f(cname); + if val.is_null() { + reset_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_gpa_session_results: unsafe { + extern "system" fn cmd_copy_gpa_session_results_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_gpa_session_results_amd) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyGpaSessionResultsAMD\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_gpa_session_results_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } + pub unsafe fn create_gpa_session( + &self, + device: Device, + create_info: *const GpaSessionCreateInfoAmd, + allocator: *const AllocationCallbacks, + gpa_session: *mut GpaSessionAmd, + ) -> Result { + (self.create_gpa_session)(device, create_info, allocator, gpa_session) + } + pub unsafe fn destroy_gpa_session( + &self, + device: Device, + gpa_session: GpaSessionAmd, + allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_gpa_session)(device, gpa_session, allocator) + } +} + +// Extension: `VK_AMD_wave_limits` + +impl StructureType { + pub const WAVE_LIMIT_AMD: Self = Self(1000045000); + pub const PHYSICAL_DEVICE_WAVE_LIMIT_PROPERTIES_AMD: Self = Self(1000045001); +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct PhysicalDeviceWaveLimitPropertiesAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub cu_count: u32, + pub max_waves_per_cu: u32, +} + +impl ::std::default::Default for PhysicalDeviceWaveLimitPropertiesAmd { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_WAVE_LIMIT_PROPERTIES_AMD, + p_next: ::std::ptr::null_mut(), + cu_count: u32::default(), + max_waves_per_cu: u32::default(), + } + } +} +impl PhysicalDeviceWaveLimitPropertiesAmd { + pub fn builder<'a>() -> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { + PhysicalDeviceWaveLimitPropertiesAmdBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { + inner: PhysicalDeviceWaveLimitPropertiesAmd, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceWaveLimitPropertiesAmd {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceWaveLimitPropertiesAmd {} +impl<'a> ::std::ops::Deref for PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { + type Target = PhysicalDeviceWaveLimitPropertiesAmd; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { + pub fn push_next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> + where + T: ExtendsPhysicalDeviceWaveLimitPropertiesAmd, + { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + pub fn build(self) -> PhysicalDeviceWaveLimitPropertiesAmd { + self.inner + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct PipelineShaderStageCreateInfoWaveLimitAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub waves_per_cu: f32, + pub cu_enable_mask: *mut u32, +} diff --git a/third_party/rust/ash/src/extensions/experimental/mod.rs b/third_party/rust/ash/src/extensions/experimental/mod.rs new file mode 100644 index 0000000000..49e51f80c3 --- /dev/null +++ b/third_party/rust/ash/src/extensions/experimental/mod.rs @@ -0,0 +1 @@ +pub mod amd; diff --git a/third_party/rust/ash/src/extensions/ext/acquire_drm_display.rs b/third_party/rust/ash/src/extensions/ext/acquire_drm_display.rs new file mode 100644 index 0000000000..8c80e506e0 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/acquire_drm_display.rs @@ -0,0 +1,55 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct AcquireDrmDisplay { + fp: vk::ExtAcquireDrmDisplayFn, +} + +impl AcquireDrmDisplay { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtAcquireDrmDisplayFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn acquire_drm_display( + &self, + physical_device: vk::PhysicalDevice, + drm_fd: i32, + display: vk::DisplayKHR, + ) -> VkResult<()> { + (self.fp.acquire_drm_display_ext)(physical_device, drm_fd, display).result() + } + + /// + #[inline] + pub unsafe fn get_drm_display( + &self, + physical_device: vk::PhysicalDevice, + drm_fd: i32, + connector_id: u32, + ) -> VkResult { + let mut display = mem::MaybeUninit::uninit(); + (self.fp.get_drm_display_ext)(physical_device, drm_fd, connector_id, display.as_mut_ptr()) + .assume_init_on_success(display) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtAcquireDrmDisplayFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtAcquireDrmDisplayFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/buffer_device_address.rs b/third_party/rust/ash/src/extensions/ext/buffer_device_address.rs new file mode 100644 index 0000000000..a1d304e639 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/buffer_device_address.rs @@ -0,0 +1,44 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct BufferDeviceAddress { + handle: vk::Device, + fp: vk::ExtBufferDeviceAddressFn, +} + +impl BufferDeviceAddress { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtBufferDeviceAddressFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_buffer_device_address( + &self, + info: &vk::BufferDeviceAddressInfoEXT, + ) -> vk::DeviceAddress { + (self.fp.get_buffer_device_address_ext)(self.handle, info) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtBufferDeviceAddressFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtBufferDeviceAddressFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/calibrated_timestamps.rs b/third_party/rust/ash/src/extensions/ext/calibrated_timestamps.rs new file mode 100644 index 0000000000..e102fca15c --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/calibrated_timestamps.rs @@ -0,0 +1,72 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct CalibratedTimestamps { + handle: vk::Instance, + fp: vk::ExtCalibratedTimestampsFn, +} + +impl CalibratedTimestamps { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtCalibratedTimestampsFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_calibrateable_time_domains( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_calibrateable_time_domains_ext)( + physical_device, + count, + data, + ) + }) + } + + /// + /// + /// Returns a tuple containing `(timestamps, max_deviation)` + #[inline] + pub unsafe fn get_calibrated_timestamps( + &self, + device: vk::Device, + info: &[vk::CalibratedTimestampInfoEXT], + ) -> VkResult<(Vec, Vec)> { + let mut timestamps = vec![0u64; info.len()]; + let mut max_deviation = vec![0u64; info.len()]; + (self.fp.get_calibrated_timestamps_ext)( + device, + info.len() as u32, + info.as_ptr(), + timestamps.as_mut_ptr(), + max_deviation.as_mut_ptr(), + ) + .result_with_success((timestamps, max_deviation)) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtCalibratedTimestampsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtCalibratedTimestampsFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/debug_marker.rs b/third_party/rust/ash/src/extensions/ext/debug_marker.rs new file mode 100755 index 0000000000..1c21a47fd9 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/debug_marker.rs @@ -0,0 +1,71 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DebugMarker { + handle: vk::Device, + fp: vk::ExtDebugMarkerFn, +} + +impl DebugMarker { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtDebugMarkerFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn debug_marker_set_object_name( + &self, + name_info: &vk::DebugMarkerObjectNameInfoEXT, + ) -> VkResult<()> { + (self.fp.debug_marker_set_object_name_ext)(self.handle, name_info).result() + } + + /// + #[inline] + pub unsafe fn cmd_debug_marker_begin( + &self, + command_buffer: vk::CommandBuffer, + marker_info: &vk::DebugMarkerMarkerInfoEXT, + ) { + (self.fp.cmd_debug_marker_begin_ext)(command_buffer, marker_info); + } + + /// + #[inline] + pub unsafe fn cmd_debug_marker_end(&self, command_buffer: vk::CommandBuffer) { + (self.fp.cmd_debug_marker_end_ext)(command_buffer); + } + + /// + #[inline] + pub unsafe fn cmd_debug_marker_insert( + &self, + command_buffer: vk::CommandBuffer, + marker_info: &vk::DebugMarkerMarkerInfoEXT, + ) { + (self.fp.cmd_debug_marker_insert_ext)(command_buffer, marker_info); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtDebugMarkerFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtDebugMarkerFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/debug_report.rs b/third_party/rust/ash/src/extensions/ext/debug_report.rs new file mode 100755 index 0000000000..625ebf479e --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/debug_report.rs @@ -0,0 +1,68 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DebugReport { + handle: vk::Instance, + fp: vk::ExtDebugReportFn, +} + +impl DebugReport { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtDebugReportFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn destroy_debug_report_callback( + &self, + debug: vk::DebugReportCallbackEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_debug_report_callback_ext)( + self.handle, + debug, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_debug_report_callback( + &self, + create_info: &vk::DebugReportCallbackCreateInfoEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut debug_cb = mem::zeroed(); + (self.fp.create_debug_report_callback_ext)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut debug_cb, + ) + .result_with_success(debug_cb) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtDebugReportFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtDebugReportFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/debug_utils.rs b/third_party/rust/ash/src/extensions/ext/debug_utils.rs new file mode 100755 index 0000000000..46d91769ad --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/debug_utils.rs @@ -0,0 +1,173 @@ +use crate::prelude::*; +use crate::{vk, RawPtr}; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DebugUtils { + handle: vk::Instance, + fp: vk::ExtDebugUtilsFn, +} + +impl DebugUtils { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtDebugUtilsFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[deprecated = "Backwards-compatible alias containing a typo, use `set_debug_utils_object_name()` instead"] + #[inline] + pub unsafe fn debug_utils_set_object_name( + &self, + device: vk::Device, + name_info: &vk::DebugUtilsObjectNameInfoEXT, + ) -> VkResult<()> { + self.set_debug_utils_object_name(device, name_info) + } + + /// + #[inline] + pub unsafe fn set_debug_utils_object_name( + &self, + device: vk::Device, + name_info: &vk::DebugUtilsObjectNameInfoEXT, + ) -> VkResult<()> { + (self.fp.set_debug_utils_object_name_ext)(device, name_info).result() + } + + /// + #[deprecated = "Backwards-compatible alias containing a typo, use `set_debug_utils_object_tag()` instead"] + #[inline] + pub unsafe fn debug_utils_set_object_tag( + &self, + device: vk::Device, + tag_info: &vk::DebugUtilsObjectTagInfoEXT, + ) -> VkResult<()> { + self.set_debug_utils_object_tag(device, tag_info) + } + + /// + #[inline] + pub unsafe fn set_debug_utils_object_tag( + &self, + device: vk::Device, + tag_info: &vk::DebugUtilsObjectTagInfoEXT, + ) -> VkResult<()> { + (self.fp.set_debug_utils_object_tag_ext)(device, tag_info).result() + } + + /// + #[inline] + pub unsafe fn cmd_begin_debug_utils_label( + &self, + command_buffer: vk::CommandBuffer, + label: &vk::DebugUtilsLabelEXT, + ) { + (self.fp.cmd_begin_debug_utils_label_ext)(command_buffer, label); + } + + /// + #[inline] + pub unsafe fn cmd_end_debug_utils_label(&self, command_buffer: vk::CommandBuffer) { + (self.fp.cmd_end_debug_utils_label_ext)(command_buffer); + } + + /// + #[inline] + pub unsafe fn cmd_insert_debug_utils_label( + &self, + command_buffer: vk::CommandBuffer, + label: &vk::DebugUtilsLabelEXT, + ) { + (self.fp.cmd_insert_debug_utils_label_ext)(command_buffer, label); + } + + /// + #[inline] + pub unsafe fn queue_begin_debug_utils_label( + &self, + queue: vk::Queue, + label: &vk::DebugUtilsLabelEXT, + ) { + (self.fp.queue_begin_debug_utils_label_ext)(queue, label); + } + + /// + #[inline] + pub unsafe fn queue_end_debug_utils_label(&self, queue: vk::Queue) { + (self.fp.queue_end_debug_utils_label_ext)(queue); + } + + /// + #[inline] + pub unsafe fn queue_insert_debug_utils_label( + &self, + queue: vk::Queue, + label: &vk::DebugUtilsLabelEXT, + ) { + (self.fp.queue_insert_debug_utils_label_ext)(queue, label); + } + + /// + #[inline] + pub unsafe fn create_debug_utils_messenger( + &self, + create_info: &vk::DebugUtilsMessengerCreateInfoEXT, + allocator: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut messenger = mem::zeroed(); + (self.fp.create_debug_utils_messenger_ext)( + self.handle, + create_info, + allocator.as_raw_ptr(), + &mut messenger, + ) + .result_with_success(messenger) + } + + /// + #[inline] + pub unsafe fn destroy_debug_utils_messenger( + &self, + messenger: vk::DebugUtilsMessengerEXT, + allocator: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_debug_utils_messenger_ext)(self.handle, messenger, allocator.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn submit_debug_utils_message( + &self, + message_severity: vk::DebugUtilsMessageSeverityFlagsEXT, + message_types: vk::DebugUtilsMessageTypeFlagsEXT, + callback_data: &vk::DebugUtilsMessengerCallbackDataEXT, + ) { + (self.fp.submit_debug_utils_message_ext)( + self.handle, + message_severity, + message_types, + callback_data, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtDebugUtilsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtDebugUtilsFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/descriptor_buffer.rs b/third_party/rust/ash/src/extensions/ext/descriptor_buffer.rs new file mode 100644 index 0000000000..4503f5bdab --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/descriptor_buffer.rs @@ -0,0 +1,211 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct DescriptorBuffer { + handle: vk::Device, + fp: vk::ExtDescriptorBufferFn, +} + +impl DescriptorBuffer { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtDescriptorBufferFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_descriptor_set_layout_size( + &self, + layout: vk::DescriptorSetLayout, + ) -> vk::DeviceSize { + let mut count = 0; + (self.fp.get_descriptor_set_layout_size_ext)(self.handle, layout, &mut count); + count + } + + /// + #[inline] + pub unsafe fn get_descriptor_set_layout_binding_offset( + &self, + layout: vk::DescriptorSetLayout, + binding: u32, + ) -> vk::DeviceSize { + let mut offset = 0; + (self.fp.get_descriptor_set_layout_binding_offset_ext)( + self.handle, + layout, + binding, + &mut offset, + ); + offset + } + + /// + #[inline] + pub unsafe fn get_descriptor( + &self, + descriptor_info: &vk::DescriptorGetInfoEXT, + descriptor: &mut [u8], + ) { + (self.fp.get_descriptor_ext)( + self.handle, + descriptor_info, + descriptor.len(), + descriptor.as_mut_ptr().cast(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_bind_descriptor_buffers( + &self, + command_buffer: vk::CommandBuffer, + binding_info: &[vk::DescriptorBufferBindingInfoEXT], + ) { + (self.fp.cmd_bind_descriptor_buffers_ext)( + command_buffer, + binding_info.len() as u32, + binding_info.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_descriptor_buffer_offsets( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + layout: vk::PipelineLayout, + first_set: u32, + buffer_indices: &[u32], + offsets: &[vk::DeviceSize], + ) { + assert_eq!(buffer_indices.len(), offsets.len()); + (self.fp.cmd_set_descriptor_buffer_offsets_ext)( + command_buffer, + pipeline_bind_point, + layout, + first_set, + buffer_indices.len() as u32, + buffer_indices.as_ptr(), + offsets.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_bind_descriptor_buffer_embedded_samplers( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + layout: vk::PipelineLayout, + set: u32, + ) { + (self.fp.cmd_bind_descriptor_buffer_embedded_samplers_ext)( + command_buffer, + pipeline_bind_point, + layout, + set, + ) + } + + /// + #[inline] + pub unsafe fn get_buffer_opaque_capture_descriptor_data( + &self, + info: &vk::BufferCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_buffer_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_image_opaque_capture_descriptor_data( + &self, + info: &vk::ImageCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_image_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_image_view_opaque_capture_descriptor_data( + &self, + info: &vk::ImageViewCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_image_view_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_sampler_opaque_capture_descriptor_data( + &self, + info: &vk::SamplerCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_sampler_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_opaque_capture_descriptor_data( + &self, + info: &vk::AccelerationStructureCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self + .fp + .get_acceleration_structure_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtDescriptorBufferFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtDescriptorBufferFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/extended_dynamic_state.rs b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state.rs new file mode 100644 index 0000000000..2e6b3eeca3 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state.rs @@ -0,0 +1,196 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +#[derive(Clone)] +pub struct ExtendedDynamicState { + fp: vk::ExtExtendedDynamicStateFn, +} + +impl ExtendedDynamicState { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::ExtExtendedDynamicStateFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_set_cull_mode( + &self, + command_buffer: vk::CommandBuffer, + cull_mode: vk::CullModeFlags, + ) { + (self.fp.cmd_set_cull_mode_ext)(command_buffer, cull_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_front_face( + &self, + command_buffer: vk::CommandBuffer, + front_face: vk::FrontFace, + ) { + (self.fp.cmd_set_front_face_ext)(command_buffer, front_face) + } + + /// + #[inline] + pub unsafe fn cmd_set_primitive_topology( + &self, + command_buffer: vk::CommandBuffer, + primitive_topology: vk::PrimitiveTopology, + ) { + (self.fp.cmd_set_primitive_topology_ext)(command_buffer, primitive_topology) + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport_with_count( + &self, + command_buffer: vk::CommandBuffer, + viewports: &[vk::Viewport], + ) { + (self.fp.cmd_set_viewport_with_count_ext)( + command_buffer, + viewports.len() as u32, + viewports.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_scissor_with_count( + &self, + command_buffer: vk::CommandBuffer, + scissors: &[vk::Rect2D], + ) { + (self.fp.cmd_set_scissor_with_count_ext)( + command_buffer, + scissors.len() as u32, + scissors.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_bind_vertex_buffers2( + &self, + command_buffer: vk::CommandBuffer, + first_binding: u32, + buffers: &[vk::Buffer], + offsets: &[vk::DeviceSize], + sizes: Option<&[vk::DeviceSize]>, + strides: Option<&[vk::DeviceSize]>, + ) { + assert_eq!(offsets.len(), buffers.len()); + let p_sizes = if let Some(sizes) = sizes { + assert_eq!(sizes.len(), buffers.len()); + sizes.as_ptr() + } else { + ptr::null() + }; + let p_strides = if let Some(strides) = strides { + assert_eq!(strides.len(), buffers.len()); + strides.as_ptr() + } else { + ptr::null() + }; + (self.fp.cmd_bind_vertex_buffers2_ext)( + command_buffer, + first_binding, + buffers.len() as u32, + buffers.as_ptr(), + offsets.as_ptr(), + p_sizes, + p_strides, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_test_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_test_enable: bool, + ) { + (self.fp.cmd_set_depth_test_enable_ext)(command_buffer, depth_test_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_write_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_write_enable: bool, + ) { + (self.fp.cmd_set_depth_write_enable_ext)(command_buffer, depth_write_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_compare_op( + &self, + command_buffer: vk::CommandBuffer, + depth_compare_op: vk::CompareOp, + ) { + (self.fp.cmd_set_depth_compare_op_ext)(command_buffer, depth_compare_op) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bounds_test_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_bounds_test_enable: bool, + ) { + (self.fp.cmd_set_depth_bounds_test_enable_ext)( + command_buffer, + depth_bounds_test_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_test_enable( + &self, + command_buffer: vk::CommandBuffer, + stencil_test_enable: bool, + ) { + (self.fp.cmd_set_stencil_test_enable_ext)(command_buffer, stencil_test_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_op( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + fail_op: vk::StencilOp, + pass_op: vk::StencilOp, + depth_fail_op: vk::StencilOp, + compare_op: vk::CompareOp, + ) { + (self.fp.cmd_set_stencil_op_ext)( + command_buffer, + face_mask, + fail_op, + pass_op, + depth_fail_op, + compare_op, + ) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtExtendedDynamicStateFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtExtendedDynamicStateFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/extended_dynamic_state2.rs b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state2.rs new file mode 100644 index 0000000000..b515385930 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state2.rs @@ -0,0 +1,85 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct ExtendedDynamicState2 { + fp: vk::ExtExtendedDynamicState2Fn, +} + +impl ExtendedDynamicState2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::ExtExtendedDynamicState2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_set_patch_control_points( + &self, + command_buffer: vk::CommandBuffer, + patch_control_points: u32, + ) { + (self.fp.cmd_set_patch_control_points_ext)(command_buffer, patch_control_points) + } + + /// + #[inline] + pub unsafe fn cmd_set_rasterizer_discard_enable( + &self, + command_buffer: vk::CommandBuffer, + rasterizer_discard_enable: bool, + ) { + (self.fp.cmd_set_rasterizer_discard_enable_ext)( + command_buffer, + rasterizer_discard_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bias_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_bias_enable: bool, + ) { + (self.fp.cmd_set_depth_bias_enable_ext)(command_buffer, depth_bias_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_logic_op( + &self, + command_buffer: vk::CommandBuffer, + logic_op: vk::LogicOp, + ) { + (self.fp.cmd_set_logic_op_ext)(command_buffer, logic_op) + } + + /// + #[inline] + pub unsafe fn cmd_set_primitive_restart_enable( + &self, + command_buffer: vk::CommandBuffer, + primitive_restart_enable: bool, + ) { + (self.fp.cmd_set_primitive_restart_enable_ext)( + command_buffer, + primitive_restart_enable.into(), + ) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtExtendedDynamicState2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtExtendedDynamicState2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/extended_dynamic_state3.rs b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state3.rs new file mode 100644 index 0000000000..bb68f75f3e --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state3.rs @@ -0,0 +1,409 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct ExtendedDynamicState3 { + fp: vk::ExtExtendedDynamicState3Fn, +} + +impl ExtendedDynamicState3 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::ExtExtendedDynamicState3Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_set_tessellation_domain_origin( + &self, + command_buffer: vk::CommandBuffer, + domain_origin: vk::TessellationDomainOrigin, + ) { + (self.fp.cmd_set_tessellation_domain_origin_ext)(command_buffer, domain_origin) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_clamp_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_clamp_enable: bool, + ) { + (self.fp.cmd_set_depth_clamp_enable_ext)(command_buffer, depth_clamp_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_polygon_mode( + &self, + command_buffer: vk::CommandBuffer, + polygon_mode: vk::PolygonMode, + ) { + (self.fp.cmd_set_polygon_mode_ext)(command_buffer, polygon_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_rasterization_samples( + &self, + command_buffer: vk::CommandBuffer, + rasterization_samples: vk::SampleCountFlags, + ) { + (self.fp.cmd_set_rasterization_samples_ext)(command_buffer, rasterization_samples) + } + + /// + #[inline] + pub unsafe fn cmd_set_sample_mask( + &self, + command_buffer: vk::CommandBuffer, + samples: vk::SampleCountFlags, + sample_mask: &[vk::SampleMask], + ) { + assert!( + samples.as_raw().is_power_of_two(), + "Only one SampleCount bit must be set" + ); + assert_eq!(samples.as_raw() as usize / 32, sample_mask.len()); + (self.fp.cmd_set_sample_mask_ext)(command_buffer, samples, sample_mask.as_ptr()) + } + + /// + #[inline] + pub unsafe fn cmd_set_alpha_to_coverage_enable( + &self, + command_buffer: vk::CommandBuffer, + alpha_to_coverage_enable: bool, + ) { + (self.fp.cmd_set_alpha_to_coverage_enable_ext)( + command_buffer, + alpha_to_coverage_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_alpha_to_one_enable( + &self, + command_buffer: vk::CommandBuffer, + alpha_to_one_enable: bool, + ) { + (self.fp.cmd_set_alpha_to_one_enable_ext)(command_buffer, alpha_to_one_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_logic_op_enable( + &self, + command_buffer: vk::CommandBuffer, + logic_op_enable: bool, + ) { + (self.fp.cmd_set_logic_op_enable_ext)(command_buffer, logic_op_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_color_blend_enable( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + color_blend_enables: &[vk::Bool32], + ) { + (self.fp.cmd_set_color_blend_enable_ext)( + command_buffer, + first_attachment, + color_blend_enables.len() as u32, + color_blend_enables.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_color_blend_equation( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + color_blend_equations: &[vk::ColorBlendEquationEXT], + ) { + (self.fp.cmd_set_color_blend_equation_ext)( + command_buffer, + first_attachment, + color_blend_equations.len() as u32, + color_blend_equations.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_color_write_mask( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + color_write_masks: &[vk::ColorComponentFlags], + ) { + (self.fp.cmd_set_color_write_mask_ext)( + command_buffer, + first_attachment, + color_write_masks.len() as u32, + color_write_masks.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_rasterization_stream( + &self, + command_buffer: vk::CommandBuffer, + rasterization_stream: u32, + ) { + (self.fp.cmd_set_rasterization_stream_ext)(command_buffer, rasterization_stream) + } + + /// + #[inline] + pub unsafe fn cmd_set_conservative_rasterization_mode( + &self, + command_buffer: vk::CommandBuffer, + conservative_rasterization_mode: vk::ConservativeRasterizationModeEXT, + ) { + (self.fp.cmd_set_conservative_rasterization_mode_ext)( + command_buffer, + conservative_rasterization_mode, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_extra_primitive_overestimation_size( + &self, + command_buffer: vk::CommandBuffer, + extra_primitive_overestimation_size: f32, + ) { + (self.fp.cmd_set_extra_primitive_overestimation_size_ext)( + command_buffer, + extra_primitive_overestimation_size, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_clip_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_clip_enable: bool, + ) { + (self.fp.cmd_set_depth_clip_enable_ext)(command_buffer, depth_clip_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_sample_locations_enable( + &self, + command_buffer: vk::CommandBuffer, + sample_locations_enable: bool, + ) { + (self.fp.cmd_set_sample_locations_enable_ext)( + command_buffer, + sample_locations_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_color_blend_advanced( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + color_blend_advanced: &[vk::ColorBlendAdvancedEXT], + ) { + (self.fp.cmd_set_color_blend_advanced_ext)( + command_buffer, + first_attachment, + color_blend_advanced.len() as u32, + color_blend_advanced.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_provoking_vertex_mode( + &self, + command_buffer: vk::CommandBuffer, + provoking_vertex_mode: vk::ProvokingVertexModeEXT, + ) { + (self.fp.cmd_set_provoking_vertex_mode_ext)(command_buffer, provoking_vertex_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_line_rasterization_mode( + &self, + command_buffer: vk::CommandBuffer, + line_rasterization_mode: vk::LineRasterizationModeEXT, + ) { + (self.fp.cmd_set_line_rasterization_mode_ext)(command_buffer, line_rasterization_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_line_stipple_enable( + &self, + command_buffer: vk::CommandBuffer, + stippled_line_enable: bool, + ) { + (self.fp.cmd_set_line_stipple_enable_ext)(command_buffer, stippled_line_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_clip_negative_one_to_one( + &self, + command_buffer: vk::CommandBuffer, + negative_one_to_one: bool, + ) { + (self.fp.cmd_set_depth_clip_negative_one_to_one_ext)( + command_buffer, + negative_one_to_one.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport_w_scaling_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + viewport_w_scaling_enable: bool, + ) { + (self.fp.cmd_set_viewport_w_scaling_enable_nv)( + command_buffer, + viewport_w_scaling_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport_swizzle_nv( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + viewport_swizzles: &[vk::ViewportSwizzleNV], + ) { + (self.fp.cmd_set_viewport_swizzle_nv)( + command_buffer, + first_attachment, + viewport_swizzles.len() as u32, + viewport_swizzles.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_to_color_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_to_color_enable: bool, + ) { + (self.fp.cmd_set_coverage_to_color_enable_nv)( + command_buffer, + coverage_to_color_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_to_color_location_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_to_color_location: u32, + ) { + (self.fp.cmd_set_coverage_to_color_location_nv)(command_buffer, coverage_to_color_location) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_modulation_mode_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_modulation_mode: vk::CoverageModulationModeNV, + ) { + (self.fp.cmd_set_coverage_modulation_mode_nv)(command_buffer, coverage_modulation_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_modulation_table_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_modulation_table_enable: bool, + ) { + (self.fp.cmd_set_coverage_modulation_table_enable_nv)( + command_buffer, + coverage_modulation_table_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_modulation_table_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_modulation_table: &[f32], + ) { + (self.fp.cmd_set_coverage_modulation_table_nv)( + command_buffer, + coverage_modulation_table.len() as u32, + coverage_modulation_table.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_shading_rate_image_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + shading_rate_image_enable: bool, + ) { + (self.fp.cmd_set_shading_rate_image_enable_nv)( + command_buffer, + shading_rate_image_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_representative_fragment_test_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + representative_fragment_test_enable: bool, + ) { + (self.fp.cmd_set_representative_fragment_test_enable_nv)( + command_buffer, + representative_fragment_test_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_reduction_mode_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_reduction_mode: vk::CoverageReductionModeNV, + ) { + (self.fp.cmd_set_coverage_reduction_mode_nv)(command_buffer, coverage_reduction_mode) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtExtendedDynamicState3Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtExtendedDynamicState3Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/full_screen_exclusive.rs b/third_party/rust/ash/src/extensions/ext/full_screen_exclusive.rs new file mode 100644 index 0000000000..3cb73cdaeb --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/full_screen_exclusive.rs @@ -0,0 +1,86 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct FullScreenExclusive { + handle: vk::Device, + fp: vk::ExtFullScreenExclusiveFn, +} + +impl FullScreenExclusive { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtFullScreenExclusiveFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn acquire_full_screen_exclusive_mode( + &self, + swapchain: vk::SwapchainKHR, + ) -> VkResult<()> { + (self.fp.acquire_full_screen_exclusive_mode_ext)(self.handle, swapchain).result() + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_present_modes2( + &self, + physical_device: vk::PhysicalDevice, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_surface_present_modes2_ext)( + physical_device, + surface_info, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn release_full_screen_exclusive_mode( + &self, + swapchain: vk::SwapchainKHR, + ) -> VkResult<()> { + (self.fp.release_full_screen_exclusive_mode_ext)(self.handle, swapchain).result() + } + + /// + #[inline] + pub unsafe fn get_device_group_surface_present_modes2( + &self, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + ) -> VkResult { + let mut present_modes = mem::zeroed(); + (self.fp.get_device_group_surface_present_modes2_ext)( + self.handle, + surface_info, + &mut present_modes, + ) + .result_with_success(present_modes) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtFullScreenExclusiveFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtFullScreenExclusiveFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/headless_surface.rs b/third_party/rust/ash/src/extensions/ext/headless_surface.rs new file mode 100644 index 0000000000..fe04236aaf --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/headless_surface.rs @@ -0,0 +1,55 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct HeadlessSurface { + handle: vk::Instance, + fp: vk::ExtHeadlessSurfaceFn, +} + +impl HeadlessSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtHeadlessSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_headless_surface( + &self, + create_info: &vk::HeadlessSurfaceCreateInfoEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_headless_surface_ext)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtHeadlessSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtHeadlessSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/image_compression_control.rs b/third_party/rust/ash/src/extensions/ext/image_compression_control.rs new file mode 100644 index 0000000000..a326116973 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/image_compression_control.rs @@ -0,0 +1,47 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct ImageCompressionControl { + handle: vk::Device, + fp: vk::ExtImageCompressionControlFn, +} + +impl ImageCompressionControl { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtImageCompressionControlFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_image_subresource_layout2( + &self, + image: vk::Image, + subresource: &vk::ImageSubresource2EXT, + layout: &mut vk::SubresourceLayout2EXT, + ) { + (self.fp.get_image_subresource_layout2_ext)(self.handle, image, subresource, layout) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtImageCompressionControlFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtImageCompressionControlFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/image_drm_format_modifier.rs b/third_party/rust/ash/src/extensions/ext/image_drm_format_modifier.rs new file mode 100644 index 0000000000..ccdce2eb5e --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/image_drm_format_modifier.rs @@ -0,0 +1,48 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct ImageDrmFormatModifier { + handle: vk::Device, + fp: vk::ExtImageDrmFormatModifierFn, +} + +impl ImageDrmFormatModifier { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtImageDrmFormatModifierFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_image_drm_format_modifier_properties( + &self, + image: vk::Image, + properties: &mut vk::ImageDrmFormatModifierPropertiesEXT, + ) -> VkResult<()> { + (self.fp.get_image_drm_format_modifier_properties_ext)(self.handle, image, properties) + .result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtImageDrmFormatModifierFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtImageDrmFormatModifierFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/mesh_shader.rs b/third_party/rust/ash/src/extensions/ext/mesh_shader.rs new file mode 100644 index 0000000000..7d58f0c135 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/mesh_shader.rs @@ -0,0 +1,94 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct MeshShader { + fp: vk::ExtMeshShaderFn, +} + +impl MeshShader { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::ExtMeshShaderFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_draw_mesh_tasks( + &self, + command_buffer: vk::CommandBuffer, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_ext)( + command_buffer, + group_count_x, + group_count_y, + group_count_z, + ); + } + + /// + /// + /// `buffer` contains `draw_count` [`vk::DrawMeshTasksIndirectCommandEXT`] structures starting at `offset` in bytes, holding the draw parameters. + #[inline] + pub unsafe fn cmd_draw_mesh_tasks_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_indirect_ext)( + command_buffer, + buffer, + offset, + draw_count, + stride, + ); + } + + /// + /// + /// `buffer` contains a maximum of `max_draw_count` [`vk::DrawMeshTasksIndirectCommandEXT`] structures starting at `offset` in bytes, holding the draw parameters. + /// `count_buffer` is the buffer containing the draw count, starting at `count_buffer_offset` in bytes. + /// The actual number of executed draw calls is the minimum of the count specified in `count_buffer` and `max_draw_count`. + #[inline] + pub unsafe fn cmd_draw_mesh_tasks_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_indirect_count_ext)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtMeshShaderFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtMeshShaderFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/metal_surface.rs b/third_party/rust/ash/src/extensions/ext/metal_surface.rs new file mode 100644 index 0000000000..9627d2f510 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/metal_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct MetalSurface { + handle: vk::Instance, + fp: vk::ExtMetalSurfaceFn, +} + +impl MetalSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtMetalSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_metal_surface( + &self, + create_info: &vk::MetalSurfaceCreateInfoEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_metal_surface_ext)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtMetalSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtMetalSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/mod.rs b/third_party/rust/ash/src/extensions/ext/mod.rs new file mode 100644 index 0000000000..26a78f77d6 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/mod.rs @@ -0,0 +1,45 @@ +pub use self::acquire_drm_display::AcquireDrmDisplay; +pub use self::buffer_device_address::BufferDeviceAddress; +pub use self::calibrated_timestamps::CalibratedTimestamps; +#[allow(deprecated)] +pub use self::debug_marker::DebugMarker; +#[allow(deprecated)] +pub use self::debug_report::DebugReport; +pub use self::debug_utils::DebugUtils; +pub use self::descriptor_buffer::DescriptorBuffer; +pub use self::extended_dynamic_state::ExtendedDynamicState; +pub use self::extended_dynamic_state2::ExtendedDynamicState2; +pub use self::extended_dynamic_state3::ExtendedDynamicState3; +pub use self::full_screen_exclusive::FullScreenExclusive; +pub use self::headless_surface::HeadlessSurface; +pub use self::image_compression_control::ImageCompressionControl; +pub use self::image_drm_format_modifier::ImageDrmFormatModifier; +pub use self::mesh_shader::MeshShader; +pub use self::metal_surface::MetalSurface; +pub use self::physical_device_drm::PhysicalDeviceDrm; +pub use self::private_data::PrivateData; +pub use self::sample_locations::SampleLocations; +pub use self::tooling_info::ToolingInfo; + +mod acquire_drm_display; +mod buffer_device_address; +mod calibrated_timestamps; +#[deprecated(note = "Please use the [DebugUtils](struct.DebugUtils.html) extension instead.")] +mod debug_marker; +#[deprecated(note = "Please use the [DebugUtils](struct.DebugUtils.html) extension instead.")] +mod debug_report; +mod debug_utils; +mod descriptor_buffer; +mod extended_dynamic_state; +mod extended_dynamic_state2; +mod extended_dynamic_state3; +mod full_screen_exclusive; +mod headless_surface; +mod image_compression_control; +mod image_drm_format_modifier; +mod mesh_shader; +mod metal_surface; +mod physical_device_drm; +mod private_data; +mod sample_locations; +mod tooling_info; diff --git a/third_party/rust/ash/src/extensions/ext/physical_device_drm.rs b/third_party/rust/ash/src/extensions/ext/physical_device_drm.rs new file mode 100644 index 0000000000..29b6cd7b32 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/physical_device_drm.rs @@ -0,0 +1,26 @@ +use crate::vk; +use crate::Instance; +use std::ffi::CStr; + +#[derive(Clone)] +pub struct PhysicalDeviceDrm; + +impl PhysicalDeviceDrm { + #[inline] + pub unsafe fn get_properties( + instance: &Instance, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceDrmPropertiesEXT { + let mut props_drm = vk::PhysicalDeviceDrmPropertiesEXT::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_drm); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_drm + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtPhysicalDeviceDrmFn::name() + } +} diff --git a/third_party/rust/ash/src/extensions/ext/private_data.rs b/third_party/rust/ash/src/extensions/ext/private_data.rs new file mode 100644 index 0000000000..c6cc6aefb1 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/private_data.rs @@ -0,0 +1,105 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct PrivateData { + handle: vk::Device, + fp: vk::ExtPrivateDataFn, +} + +impl PrivateData { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtPrivateDataFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_private_data_slot( + &self, + create_info: &vk::PrivateDataSlotCreateInfoEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut private_data_slot = mem::zeroed(); + (self.fp.create_private_data_slot_ext)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut private_data_slot, + ) + .result_with_success(private_data_slot) + } + + /// + #[inline] + pub unsafe fn destroy_private_data_slot( + &self, + private_data_slot: vk::PrivateDataSlotEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_private_data_slot_ext)( + self.handle, + private_data_slot, + allocation_callbacks.as_raw_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn set_private_data( + &self, + object: T, + private_data_slot: vk::PrivateDataSlotEXT, + data: u64, + ) -> VkResult<()> { + (self.fp.set_private_data_ext)( + self.handle, + T::TYPE, + object.as_raw(), + private_data_slot, + data, + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_private_data( + &self, + object: T, + private_data_slot: vk::PrivateDataSlotEXT, + ) -> u64 { + let mut data = mem::zeroed(); + (self.fp.get_private_data_ext)( + self.handle, + T::TYPE, + object.as_raw(), + private_data_slot, + &mut data, + ); + data + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtPrivateDataFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtPrivateDataFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/sample_locations.rs b/third_party/rust/ash/src/extensions/ext/sample_locations.rs new file mode 100644 index 0000000000..360b83a681 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/sample_locations.rs @@ -0,0 +1,54 @@ +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct SampleLocations { + fp: vk::ExtSampleLocationsFn, +} + +impl SampleLocations { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::ExtSampleLocationsFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_multisample_properties( + &self, + physical_device: vk::PhysicalDevice, + samples: vk::SampleCountFlags, + multisample_properties: &mut vk::MultisamplePropertiesEXT, + ) { + (self.fp.get_physical_device_multisample_properties_ext)( + physical_device, + samples, + multisample_properties, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_sample_locations( + &self, + command_buffer: vk::CommandBuffer, + sample_locations_info: &vk::SampleLocationsInfoEXT, + ) { + (self.fp.cmd_set_sample_locations_ext)(command_buffer, sample_locations_info) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtSampleLocationsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtSampleLocationsFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/tooling_info.rs b/third_party/rust/ash/src/extensions/ext/tooling_info.rs new file mode 100644 index 0000000000..fd4bf994e7 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/tooling_info.rs @@ -0,0 +1,40 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ToolingInfo { + fp: vk::ExtToolingInfoFn, +} + +impl ToolingInfo { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::ExtToolingInfoFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_tool_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_defaulted_vector(|count, data| { + (self.fp.get_physical_device_tool_properties_ext)(physical_device, count, data) + }) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtToolingInfoFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtToolingInfoFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/acceleration_structure.rs b/third_party/rust/ash/src/extensions/khr/acceleration_structure.rs new file mode 100644 index 0000000000..9772e9baf4 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/acceleration_structure.rs @@ -0,0 +1,322 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct AccelerationStructure { + handle: vk::Device, + fp: vk::KhrAccelerationStructureFn, +} + +impl AccelerationStructure { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrAccelerationStructureFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + #[inline] + pub unsafe fn get_properties( + instance: &Instance, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceAccelerationStructurePropertiesKHR { + let mut props_rt = vk::PhysicalDeviceAccelerationStructurePropertiesKHR::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_rt + } + + /// + #[inline] + pub unsafe fn create_acceleration_structure( + &self, + create_info: &vk::AccelerationStructureCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut accel_struct = mem::zeroed(); + (self.fp.create_acceleration_structure_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut accel_struct, + ) + .result_with_success(accel_struct) + } + + /// + #[inline] + pub unsafe fn destroy_acceleration_structure( + &self, + accel_struct: vk::AccelerationStructureKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_acceleration_structure_khr)( + self.handle, + accel_struct, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_build_acceleration_structures( + &self, + command_buffer: vk::CommandBuffer, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + build_range_infos: &[&[vk::AccelerationStructureBuildRangeInfoKHR]], + ) { + assert_eq!(infos.len(), build_range_infos.len()); + + let build_range_infos = build_range_infos + .iter() + .zip(infos.iter()) + .map(|(range_info, info)| { + assert_eq!(range_info.len(), info.geometry_count as usize); + range_info.as_ptr() + }) + .collect::>(); + + (self.fp.cmd_build_acceleration_structures_khr)( + command_buffer, + infos.len() as _, + infos.as_ptr(), + build_range_infos.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_build_acceleration_structures_indirect( + &self, + command_buffer: vk::CommandBuffer, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + indirect_device_addresses: &[vk::DeviceAddress], + indirect_strides: &[u32], + max_primitive_counts: &[&[u32]], + ) { + assert_eq!(infos.len(), indirect_device_addresses.len()); + assert_eq!(infos.len(), indirect_strides.len()); + assert_eq!(infos.len(), max_primitive_counts.len()); + + let max_primitive_counts = max_primitive_counts + .iter() + .zip(infos.iter()) + .map(|(cnt, info)| { + assert_eq!(cnt.len(), info.geometry_count as usize); + cnt.as_ptr() + }) + .collect::>(); + + (self.fp.cmd_build_acceleration_structures_indirect_khr)( + command_buffer, + infos.len() as _, + infos.as_ptr(), + indirect_device_addresses.as_ptr(), + indirect_strides.as_ptr(), + max_primitive_counts.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn build_acceleration_structures( + &self, + deferred_operation: vk::DeferredOperationKHR, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + build_range_infos: &[&[vk::AccelerationStructureBuildRangeInfoKHR]], + ) -> VkResult<()> { + assert_eq!(infos.len(), build_range_infos.len()); + + let build_range_infos = build_range_infos + .iter() + .zip(infos.iter()) + .map(|(range_info, info)| { + assert_eq!(range_info.len(), info.geometry_count as usize); + range_info.as_ptr() + }) + .collect::>(); + + (self.fp.build_acceleration_structures_khr)( + self.handle, + deferred_operation, + infos.len() as _, + infos.as_ptr(), + build_range_infos.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn copy_acceleration_structure( + &self, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyAccelerationStructureInfoKHR, + ) -> VkResult<()> { + (self.fp.copy_acceleration_structure_khr)(self.handle, deferred_operation, info).result() + } + + /// + #[inline] + pub unsafe fn copy_acceleration_structure_to_memory( + &self, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyAccelerationStructureToMemoryInfoKHR, + ) -> VkResult<()> { + (self.fp.copy_acceleration_structure_to_memory_khr)(self.handle, deferred_operation, info) + .result() + } + + /// + #[inline] + pub unsafe fn copy_memory_to_acceleration_structure( + &self, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyMemoryToAccelerationStructureInfoKHR, + ) -> VkResult<()> { + (self.fp.copy_memory_to_acceleration_structure_khr)(self.handle, deferred_operation, info) + .result() + } + + /// + #[inline] + pub unsafe fn write_acceleration_structures_properties( + &self, + acceleration_structures: &[vk::AccelerationStructureKHR], + query_type: vk::QueryType, + data: &mut [u8], + stride: usize, + ) -> VkResult<()> { + (self.fp.write_acceleration_structures_properties_khr)( + self.handle, + acceleration_structures.len() as _, + acceleration_structures.as_ptr(), + query_type, + data.len(), + data.as_mut_ptr().cast(), + stride, + ) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_copy_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyAccelerationStructureInfoKHR, + ) { + (self.fp.cmd_copy_acceleration_structure_khr)(command_buffer, info); + } + + /// + #[inline] + pub unsafe fn cmd_copy_acceleration_structure_to_memory( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyAccelerationStructureToMemoryInfoKHR, + ) { + (self.fp.cmd_copy_acceleration_structure_to_memory_khr)(command_buffer, info); + } + + /// + #[inline] + pub unsafe fn cmd_copy_memory_to_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyMemoryToAccelerationStructureInfoKHR, + ) { + (self.fp.cmd_copy_memory_to_acceleration_structure_khr)(command_buffer, info); + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_device_address( + &self, + info: &vk::AccelerationStructureDeviceAddressInfoKHR, + ) -> vk::DeviceAddress { + (self.fp.get_acceleration_structure_device_address_khr)(self.handle, info) + } + + /// + #[inline] + pub unsafe fn cmd_write_acceleration_structures_properties( + &self, + command_buffer: vk::CommandBuffer, + structures: &[vk::AccelerationStructureKHR], + query_type: vk::QueryType, + query_pool: vk::QueryPool, + first_query: u32, + ) { + (self.fp.cmd_write_acceleration_structures_properties_khr)( + command_buffer, + structures.len() as _, + structures.as_ptr(), + query_type, + query_pool, + first_query, + ); + } + + /// + #[inline] + pub unsafe fn get_device_acceleration_structure_compatibility( + &self, + version: &vk::AccelerationStructureVersionInfoKHR, + ) -> vk::AccelerationStructureCompatibilityKHR { + let mut compatibility = vk::AccelerationStructureCompatibilityKHR::default(); + + (self.fp.get_device_acceleration_structure_compatibility_khr)( + self.handle, + version, + &mut compatibility, + ); + + compatibility + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_build_sizes( + &self, + build_type: vk::AccelerationStructureBuildTypeKHR, + build_info: &vk::AccelerationStructureBuildGeometryInfoKHR, + max_primitive_counts: &[u32], + ) -> vk::AccelerationStructureBuildSizesInfoKHR { + assert_eq!(max_primitive_counts.len(), build_info.geometry_count as _); + + let mut size_info = vk::AccelerationStructureBuildSizesInfoKHR::default(); + + (self.fp.get_acceleration_structure_build_sizes_khr)( + self.handle, + build_type, + build_info, + max_primitive_counts.as_ptr(), + &mut size_info, + ); + + size_info + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrAccelerationStructureFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrAccelerationStructureFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/android_surface.rs b/third_party/rust/ash/src/extensions/khr/android_surface.rs new file mode 100755 index 0000000000..071d367510 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/android_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct AndroidSurface { + handle: vk::Instance, + fp: vk::KhrAndroidSurfaceFn, +} + +impl AndroidSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrAndroidSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_android_surface( + &self, + create_info: &vk::AndroidSurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_android_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrAndroidSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrAndroidSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/buffer_device_address.rs b/third_party/rust/ash/src/extensions/khr/buffer_device_address.rs new file mode 100644 index 0000000000..65eae69681 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/buffer_device_address.rs @@ -0,0 +1,62 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct BufferDeviceAddress { + handle: vk::Device, + fp: vk::KhrBufferDeviceAddressFn, +} + +impl BufferDeviceAddress { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrBufferDeviceAddressFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_buffer_device_address( + &self, + info: &vk::BufferDeviceAddressInfoKHR, + ) -> vk::DeviceAddress { + (self.fp.get_buffer_device_address_khr)(self.handle, info) + } + + /// + #[inline] + pub unsafe fn get_buffer_opaque_capture_address( + &self, + info: &vk::BufferDeviceAddressInfoKHR, + ) -> u64 { + (self.fp.get_buffer_opaque_capture_address_khr)(self.handle, info) + } + + /// + #[inline] + pub unsafe fn get_device_memory_opaque_capture_address( + &self, + info: &vk::DeviceMemoryOpaqueCaptureAddressInfoKHR, + ) -> u64 { + (self.fp.get_device_memory_opaque_capture_address_khr)(self.handle, info) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrBufferDeviceAddressFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrBufferDeviceAddressFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/copy_commands2.rs b/third_party/rust/ash/src/extensions/khr/copy_commands2.rs new file mode 100644 index 0000000000..b46593093a --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/copy_commands2.rs @@ -0,0 +1,84 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct CopyCommands2 { + fp: vk::KhrCopyCommands2Fn, +} + +impl CopyCommands2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrCopyCommands2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_copy_buffer2( + &self, + command_buffer: vk::CommandBuffer, + copy_buffer_info: &vk::CopyBufferInfo2KHR, + ) { + (self.fp.cmd_copy_buffer2_khr)(command_buffer, copy_buffer_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_image2( + &self, + command_buffer: vk::CommandBuffer, + copy_image_info: &vk::CopyImageInfo2KHR, + ) { + (self.fp.cmd_copy_image2_khr)(command_buffer, copy_image_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_buffer_to_image2( + &self, + command_buffer: vk::CommandBuffer, + copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2KHR, + ) { + (self.fp.cmd_copy_buffer_to_image2_khr)(command_buffer, copy_buffer_to_image_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_image_to_buffer2( + &self, + command_buffer: vk::CommandBuffer, + copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2KHR, + ) { + (self.fp.cmd_copy_image_to_buffer2_khr)(command_buffer, copy_image_to_buffer_info) + } + /// + #[inline] + pub unsafe fn cmd_blit_image2( + &self, + command_buffer: vk::CommandBuffer, + blit_image_info: &vk::BlitImageInfo2KHR, + ) { + (self.fp.cmd_blit_image2_khr)(command_buffer, blit_image_info) + } + /// + #[inline] + pub unsafe fn cmd_resolve_image2( + &self, + command_buffer: vk::CommandBuffer, + resolve_image_info: &vk::ResolveImageInfo2KHR, + ) { + (self.fp.cmd_resolve_image2_khr)(command_buffer, resolve_image_info) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrCopyCommands2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrCopyCommands2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/create_render_pass2.rs b/third_party/rust/ash/src/extensions/khr/create_render_pass2.rs new file mode 100644 index 0000000000..bf78bc5f54 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/create_render_pass2.rs @@ -0,0 +1,90 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct CreateRenderPass2 { + handle: vk::Device, + fp: vk::KhrCreateRenderpass2Fn, +} + +impl CreateRenderPass2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrCreateRenderpass2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_render_pass2( + &self, + create_info: &vk::RenderPassCreateInfo2, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut renderpass = mem::zeroed(); + (self.fp.create_render_pass2_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut renderpass, + ) + .result_with_success(renderpass) + } + + /// + #[inline] + pub unsafe fn cmd_begin_render_pass2( + &self, + command_buffer: vk::CommandBuffer, + render_pass_begin_info: &vk::RenderPassBeginInfo, + subpass_begin_info: &vk::SubpassBeginInfo, + ) { + (self.fp.cmd_begin_render_pass2_khr)( + command_buffer, + render_pass_begin_info, + subpass_begin_info, + ); + } + + /// + #[inline] + pub unsafe fn cmd_next_subpass2( + &self, + command_buffer: vk::CommandBuffer, + subpass_begin_info: &vk::SubpassBeginInfo, + subpass_end_info: &vk::SubpassEndInfo, + ) { + (self.fp.cmd_next_subpass2_khr)(command_buffer, subpass_begin_info, subpass_end_info); + } + + /// + #[inline] + pub unsafe fn cmd_end_render_pass2( + &self, + command_buffer: vk::CommandBuffer, + subpass_end_info: &vk::SubpassEndInfo, + ) { + (self.fp.cmd_end_render_pass2_khr)(command_buffer, subpass_end_info); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrCreateRenderpass2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrCreateRenderpass2Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/deferred_host_operations.rs b/third_party/rust/ash/src/extensions/khr/deferred_host_operations.rs new file mode 100644 index 0000000000..51aeaad8bb --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/deferred_host_operations.rs @@ -0,0 +1,93 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DeferredHostOperations { + handle: vk::Device, + fp: vk::KhrDeferredHostOperationsFn, +} + +impl DeferredHostOperations { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrDeferredHostOperationsFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_deferred_operation( + &self, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut operation = mem::zeroed(); + (self.fp.create_deferred_operation_khr)( + self.handle, + allocation_callbacks.as_raw_ptr(), + &mut operation, + ) + .result_with_success(operation) + } + + /// + #[inline] + pub unsafe fn deferred_operation_join( + &self, + operation: vk::DeferredOperationKHR, + ) -> VkResult<()> { + (self.fp.deferred_operation_join_khr)(self.handle, operation).result() + } + + /// + #[inline] + pub unsafe fn destroy_deferred_operation( + &self, + operation: vk::DeferredOperationKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_deferred_operation_khr)( + self.handle, + operation, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn get_deferred_operation_max_concurrency( + &self, + operation: vk::DeferredOperationKHR, + ) -> u32 { + (self.fp.get_deferred_operation_max_concurrency_khr)(self.handle, operation) + } + + /// + #[inline] + pub unsafe fn get_deferred_operation_result( + &self, + operation: vk::DeferredOperationKHR, + ) -> VkResult<()> { + (self.fp.get_deferred_operation_result_khr)(self.handle, operation).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDeferredHostOperationsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDeferredHostOperationsFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/device_group.rs b/third_party/rust/ash/src/extensions/khr/device_group.rs new file mode 100644 index 0000000000..356db71e4d --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/device_group.rs @@ -0,0 +1,169 @@ +#[cfg(doc)] +use super::Swapchain; +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct DeviceGroup { + handle: vk::Device, + fp: vk::KhrDeviceGroupFn, +} + +impl DeviceGroup { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrDeviceGroupFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_device_group_peer_memory_features( + &self, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, + ) -> vk::PeerMemoryFeatureFlags { + let mut peer_memory_features = mem::zeroed(); + (self.fp.get_device_group_peer_memory_features_khr)( + self.handle, + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features + } + + /// + #[inline] + pub unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: u32) { + (self.fp.cmd_set_device_mask_khr)(command_buffer, device_mask) + } + + /// + #[inline] + pub unsafe fn cmd_dispatch_base( + &self, + command_buffer: vk::CommandBuffer, + base_group: (u32, u32, u32), + group_count: (u32, u32, u32), + ) { + (self.fp.cmd_dispatch_base_khr)( + command_buffer, + base_group.0, + base_group.1, + base_group.2, + group_count.0, + group_count.1, + group_count.2, + ) + } + + /// Requires [`VK_KHR_surface`] to be enabled. + /// + /// Also available as [`Swapchain::get_device_group_present_capabilities()`] since [Vulkan 1.1]. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_device_group_present_capabilities( + &self, + device_group_present_capabilities: &mut vk::DeviceGroupPresentCapabilitiesKHR, + ) -> VkResult<()> { + (self.fp.get_device_group_present_capabilities_khr)( + self.handle, + device_group_present_capabilities, + ) + .result() + } + + /// Requires [`VK_KHR_surface`] to be enabled. + /// + /// Also available as [`Swapchain::get_device_group_surface_present_modes()`] since [Vulkan 1.1]. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_device_group_surface_present_modes( + &self, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut modes = mem::zeroed(); + (self.fp.get_device_group_surface_present_modes_khr)(self.handle, surface, &mut modes) + .result_with_success(modes) + } + + /// Requires [`VK_KHR_surface`] to be enabled. + /// + /// Also available as [`Swapchain::get_physical_device_present_rectangles()`] since [Vulkan 1.1]. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_physical_device_present_rectangles( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + count, + data, + ) + }) + } + + /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface. + /// + /// Requires [`VK_KHR_swapchain`] to be enabled. + /// + /// Also available as [`Swapchain::acquire_next_image2()`] since [Vulkan 1.1]. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_swapchain`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html + #[inline] + pub unsafe fn acquire_next_image2( + &self, + acquire_info: &vk::AcquireNextImageInfoKHR, + ) -> VkResult<(u32, bool)> { + let mut index = 0; + let err_code = (self.fp.acquire_next_image2_khr)(self.handle, acquire_info, &mut index); + match err_code { + vk::Result::SUCCESS => Ok((index, false)), + vk::Result::SUBOPTIMAL_KHR => Ok((index, true)), + _ => Err(err_code), + } + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDeviceGroupFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDeviceGroupFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/device_group_creation.rs b/third_party/rust/ash/src/extensions/khr/device_group_creation.rs new file mode 100644 index 0000000000..9a21a714c9 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/device_group_creation.rs @@ -0,0 +1,66 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +/// +#[derive(Clone)] +pub struct DeviceGroupCreation { + handle: vk::Instance, + fp: vk::KhrDeviceGroupCreationFn, +} + +impl DeviceGroupCreation { + pub fn new(entry: Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrDeviceGroupCreationFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// Retrieve the number of elements to pass to [`enumerate_physical_device_groups()`][Self::enumerate_physical_device_groups()] + #[inline] + pub unsafe fn enumerate_physical_device_groups_len(&self) -> VkResult { + let mut group_count = 0; + (self.fp.enumerate_physical_device_groups_khr)( + self.handle, + &mut group_count, + ptr::null_mut(), + ) + .result_with_success(group_count as usize) + } + + /// + /// + /// Call [`enumerate_physical_device_groups_len()`][Self::enumerate_physical_device_groups_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn enumerate_physical_device_groups( + &self, + out: &mut [vk::PhysicalDeviceGroupProperties], + ) -> VkResult<()> { + let mut count = out.len() as u32; + (self.fp.enumerate_physical_device_groups_khr)(self.handle, &mut count, out.as_mut_ptr()) + .result()?; + assert_eq!(count as usize, out.len()); + Ok(()) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDeviceGroupCreationFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDeviceGroupCreationFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/display.rs b/third_party/rust/ash/src/extensions/khr/display.rs new file mode 100755 index 0000000000..b71c9c11e1 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/display.rs @@ -0,0 +1,143 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Display { + handle: vk::Instance, + fp: vk::KhrDisplayFn, +} + +impl Display { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrDisplayFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_display_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_display_properties_khr)(physical_device, count, data) + }) + } + + /// + #[inline] + pub unsafe fn get_physical_device_display_plane_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_display_plane_properties_khr)(physical_device, count, data) + }) + } + + /// + #[inline] + pub unsafe fn get_display_plane_supported_displays( + &self, + physical_device: vk::PhysicalDevice, + plane_index: u32, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_display_plane_supported_displays_khr)( + physical_device, + plane_index, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn get_display_mode_properties( + &self, + physical_device: vk::PhysicalDevice, + display: vk::DisplayKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_display_mode_properties_khr)(physical_device, display, count, data) + }) + } + + /// + #[inline] + pub unsafe fn create_display_mode( + &self, + physical_device: vk::PhysicalDevice, + display: vk::DisplayKHR, + create_info: &vk::DisplayModeCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut display_mode = mem::MaybeUninit::zeroed(); + (self.fp.create_display_mode_khr)( + physical_device, + display, + create_info, + allocation_callbacks.as_raw_ptr(), + display_mode.as_mut_ptr(), + ) + .assume_init_on_success(display_mode) + } + + /// + #[inline] + pub unsafe fn get_display_plane_capabilities( + &self, + physical_device: vk::PhysicalDevice, + mode: vk::DisplayModeKHR, + plane_index: u32, + ) -> VkResult { + let mut display_plane_capabilities = mem::MaybeUninit::zeroed(); + (self.fp.get_display_plane_capabilities_khr)( + physical_device, + mode, + plane_index, + display_plane_capabilities.as_mut_ptr(), + ) + .assume_init_on_success(display_plane_capabilities) + } + + /// + #[inline] + pub unsafe fn create_display_plane_surface( + &self, + create_info: &vk::DisplaySurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::MaybeUninit::zeroed(); + (self.fp.create_display_plane_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + surface.as_mut_ptr(), + ) + .assume_init_on_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDisplayFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDisplayFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/display_swapchain.rs b/third_party/rust/ash/src/extensions/khr/display_swapchain.rs new file mode 100755 index 0000000000..e4a33b2bdb --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/display_swapchain.rs @@ -0,0 +1,57 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DisplaySwapchain { + handle: vk::Device, + fp: vk::KhrDisplaySwapchainFn, +} + +impl DisplaySwapchain { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrDisplaySwapchainFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_shared_swapchains( + &self, + create_infos: &[vk::SwapchainCreateInfoKHR], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult> { + let mut swapchains = Vec::with_capacity(create_infos.len()); + (self.fp.create_shared_swapchains_khr)( + self.handle, + create_infos.len() as u32, + create_infos.as_ptr(), + allocation_callbacks.as_raw_ptr(), + swapchains.as_mut_ptr(), + ) + .result()?; + swapchains.set_len(create_infos.len()); + Ok(swapchains) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDisplaySwapchainFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDisplaySwapchainFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/draw_indirect_count.rs b/third_party/rust/ash/src/extensions/khr/draw_indirect_count.rs new file mode 100644 index 0000000000..f35ecbe9e3 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/draw_indirect_count.rs @@ -0,0 +1,74 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DrawIndirectCount { + fp: vk::KhrDrawIndirectCountFn, +} + +impl DrawIndirectCount { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrDrawIndirectCountFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_draw_indexed_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_indexed_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDrawIndirectCountFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDrawIndirectCountFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/dynamic_rendering.rs b/third_party/rust/ash/src/extensions/khr/dynamic_rendering.rs new file mode 100644 index 0000000000..ea6149a816 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/dynamic_rendering.rs @@ -0,0 +1,44 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DynamicRendering { + fp: vk::KhrDynamicRenderingFn, +} + +impl DynamicRendering { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrDynamicRenderingFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_begin_rendering( + &self, + command_buffer: vk::CommandBuffer, + rendering_info: &vk::RenderingInfoKHR, + ) { + (self.fp.cmd_begin_rendering_khr)(command_buffer, rendering_info) + } + + /// + #[inline] + pub unsafe fn cmd_end_rendering(&self, command_buffer: vk::CommandBuffer) { + (self.fp.cmd_end_rendering_khr)(command_buffer) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDynamicRenderingFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDynamicRenderingFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_fence_fd.rs b/third_party/rust/ash/src/extensions/khr/external_fence_fd.rs new file mode 100644 index 0000000000..6a3ec559d4 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_fence_fd.rs @@ -0,0 +1,49 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ExternalFenceFd { + handle: vk::Device, + fp: vk::KhrExternalFenceFdFn, +} + +impl ExternalFenceFd { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalFenceFdFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn import_fence_fd(&self, import_info: &vk::ImportFenceFdInfoKHR) -> VkResult<()> { + (self.fp.import_fence_fd_khr)(self.handle, import_info).result() + } + + /// + #[inline] + pub unsafe fn get_fence_fd(&self, get_info: &vk::FenceGetFdInfoKHR) -> VkResult { + let mut fd = -1; + (self.fp.get_fence_fd_khr)(self.handle, get_info, &mut fd).result_with_success(fd) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalFenceFdFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalFenceFdFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_fence_win32.rs b/third_party/rust/ash/src/extensions/khr/external_fence_win32.rs new file mode 100644 index 0000000000..627bd1cca9 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_fence_win32.rs @@ -0,0 +1,58 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +/// +#[derive(Clone)] +pub struct ExternalFenceWin32 { + handle: vk::Device, + fp: vk::KhrExternalFenceWin32Fn, +} + +impl ExternalFenceWin32 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalFenceWin32Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn import_fence_win32_handle( + &self, + import_info: &vk::ImportFenceWin32HandleInfoKHR, + ) -> VkResult<()> { + (self.fp.import_fence_win32_handle_khr)(self.handle, import_info).result() + } + + /// + #[inline] + pub unsafe fn get_fence_win32_handle( + &self, + get_info: &vk::FenceGetWin32HandleInfoKHR, + ) -> VkResult { + let mut handle = ptr::null_mut(); + (self.fp.get_fence_win32_handle_khr)(self.handle, get_info, &mut handle) + .result_with_success(handle) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalFenceWin32Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalFenceWin32Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_memory_fd.rs b/third_party/rust/ash/src/extensions/khr/external_memory_fd.rs new file mode 100644 index 0000000000..902349802f --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_memory_fd.rs @@ -0,0 +1,60 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ExternalMemoryFd { + handle: vk::Device, + fp: vk::KhrExternalMemoryFdFn, +} + +impl ExternalMemoryFd { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalMemoryFdFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_memory_fd(&self, create_info: &vk::MemoryGetFdInfoKHR) -> VkResult { + let mut fd = -1; + (self.fp.get_memory_fd_khr)(self.handle, create_info, &mut fd).result_with_success(fd) + } + + /// + #[inline] + pub unsafe fn get_memory_fd_properties( + &self, + handle_type: vk::ExternalMemoryHandleTypeFlags, + fd: i32, + ) -> VkResult { + let mut memory_fd_properties = Default::default(); + (self.fp.get_memory_fd_properties_khr)( + self.handle, + handle_type, + fd, + &mut memory_fd_properties, + ) + .result_with_success(memory_fd_properties) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalMemoryFdFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalMemoryFdFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_memory_win32.rs b/third_party/rust/ash/src/extensions/khr/external_memory_win32.rs new file mode 100644 index 0000000000..8e43a26d48 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_memory_win32.rs @@ -0,0 +1,66 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +/// +#[derive(Clone)] +pub struct ExternalMemoryWin32 { + handle: vk::Device, + fp: vk::KhrExternalMemoryWin32Fn, +} + +impl ExternalMemoryWin32 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalMemoryWin32Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_memory_win32_handle( + &self, + create_info: &vk::MemoryGetWin32HandleInfoKHR, + ) -> VkResult { + let mut handle = ptr::null_mut(); + (self.fp.get_memory_win32_handle_khr)(self.handle, create_info, &mut handle) + .result_with_success(handle) + } + + /// + #[inline] + pub unsafe fn get_memory_win32_handle_properties( + &self, + handle_type: vk::ExternalMemoryHandleTypeFlags, + handle: vk::HANDLE, + ) -> VkResult { + let mut memory_win32_handle_properties = Default::default(); + (self.fp.get_memory_win32_handle_properties_khr)( + self.handle, + handle_type, + handle, + &mut memory_win32_handle_properties, + ) + .result_with_success(memory_win32_handle_properties) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalMemoryWin32Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalMemoryWin32Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_semaphore_fd.rs b/third_party/rust/ash/src/extensions/khr/external_semaphore_fd.rs new file mode 100644 index 0000000000..eadebef40d --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_semaphore_fd.rs @@ -0,0 +1,52 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ExternalSemaphoreFd { + handle: vk::Device, + fp: vk::KhrExternalSemaphoreFdFn, +} + +impl ExternalSemaphoreFd { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalSemaphoreFdFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn import_semaphore_fd( + &self, + import_info: &vk::ImportSemaphoreFdInfoKHR, + ) -> VkResult<()> { + (self.fp.import_semaphore_fd_khr)(self.handle, import_info).result() + } + + /// + #[inline] + pub unsafe fn get_semaphore_fd(&self, get_info: &vk::SemaphoreGetFdInfoKHR) -> VkResult { + let mut fd = -1; + (self.fp.get_semaphore_fd_khr)(self.handle, get_info, &mut fd).result_with_success(fd) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalSemaphoreFdFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalSemaphoreFdFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_semaphore_win32.rs b/third_party/rust/ash/src/extensions/khr/external_semaphore_win32.rs new file mode 100644 index 0000000000..102da8c1ee --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_semaphore_win32.rs @@ -0,0 +1,58 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +/// +#[derive(Clone)] +pub struct ExternalSemaphoreWin32 { + handle: vk::Device, + fp: vk::KhrExternalSemaphoreWin32Fn, +} + +impl ExternalSemaphoreWin32 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalSemaphoreWin32Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn import_semaphore_win32_handle( + &self, + import_info: &vk::ImportSemaphoreWin32HandleInfoKHR, + ) -> VkResult<()> { + (self.fp.import_semaphore_win32_handle_khr)(self.handle, import_info).result() + } + + /// + #[inline] + pub unsafe fn get_semaphore_win32_handle( + &self, + get_info: &vk::SemaphoreGetWin32HandleInfoKHR, + ) -> VkResult { + let mut handle = ptr::null_mut(); + (self.fp.get_semaphore_win32_handle_khr)(self.handle, get_info, &mut handle) + .result_with_success(handle) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalSemaphoreWin32Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalSemaphoreWin32Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/get_memory_requirements2.rs b/third_party/rust/ash/src/extensions/khr/get_memory_requirements2.rs new file mode 100644 index 0000000000..13e5a1bf61 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/get_memory_requirements2.rs @@ -0,0 +1,92 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +#[derive(Clone)] +pub struct GetMemoryRequirements2 { + handle: vk::Device, + fp: vk::KhrGetMemoryRequirements2Fn, +} + +impl GetMemoryRequirements2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrGetMemoryRequirements2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_buffer_memory_requirements2( + &self, + info: &vk::BufferMemoryRequirementsInfo2KHR, + memory_requirements: &mut vk::MemoryRequirements2KHR, + ) { + (self.fp.get_buffer_memory_requirements2_khr)(self.handle, info, memory_requirements); + } + + /// + #[inline] + pub unsafe fn get_image_memory_requirements2( + &self, + info: &vk::ImageMemoryRequirementsInfo2KHR, + memory_requirements: &mut vk::MemoryRequirements2KHR, + ) { + (self.fp.get_image_memory_requirements2_khr)(self.handle, info, memory_requirements); + } + + /// Retrieve the number of elements to pass to [`get_image_sparse_memory_requirements2()`][Self::get_image_sparse_memory_requirements2()] + #[inline] + pub unsafe fn get_image_sparse_memory_requirements2_len( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2KHR, + ) -> usize { + let mut count = 0; + (self.fp.get_image_sparse_memory_requirements2_khr)( + self.handle, + info, + &mut count, + ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_image_sparse_memory_requirements2_len()`][Self::get_image_sparse_memory_requirements2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_image_sparse_memory_requirements2( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2KHR, + out: &mut [vk::SparseImageMemoryRequirements2KHR], + ) { + let mut count = out.len() as u32; + (self.fp.get_image_sparse_memory_requirements2_khr)( + self.handle, + info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrGetMemoryRequirements2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrGetMemoryRequirements2Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/get_physical_device_properties2.rs b/third_party/rust/ash/src/extensions/khr/get_physical_device_properties2.rs new file mode 100644 index 0000000000..9e610b4831 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/get_physical_device_properties2.rs @@ -0,0 +1,167 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +#[derive(Clone)] +pub struct GetPhysicalDeviceProperties2 { + fp: vk::KhrGetPhysicalDeviceProperties2Fn, +} + +impl GetPhysicalDeviceProperties2 { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::KhrGetPhysicalDeviceProperties2Fn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_features2( + &self, + physical_device: vk::PhysicalDevice, + features: &mut vk::PhysicalDeviceFeatures2KHR, + ) { + (self.fp.get_physical_device_features2_khr)(physical_device, features); + } + + /// + #[inline] + pub unsafe fn get_physical_device_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + format_properties: &mut vk::FormatProperties2KHR, + ) { + (self.fp.get_physical_device_format_properties2_khr)( + physical_device, + format, + format_properties, + ); + } + + /// + #[inline] + pub unsafe fn get_physical_device_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + image_format_info: &vk::PhysicalDeviceImageFormatInfo2KHR, + image_format_properties: &mut vk::ImageFormatProperties2KHR, + ) -> VkResult<()> { + (self.fp.get_physical_device_image_format_properties2_khr)( + physical_device, + image_format_info, + image_format_properties, + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_physical_device_memory_properties2( + &self, + physical_device: vk::PhysicalDevice, + memory_properties: &mut vk::PhysicalDeviceMemoryProperties2KHR, + ) { + (self.fp.get_physical_device_memory_properties2_khr)(physical_device, memory_properties); + } + + /// + #[inline] + pub unsafe fn get_physical_device_properties2( + &self, + physical_device: vk::PhysicalDevice, + properties: &mut vk::PhysicalDeviceProperties2KHR, + ) { + (self.fp.get_physical_device_properties2_khr)(physical_device, properties); + } + + /// Retrieve the number of elements to pass to [`get_physical_device_queue_family_properties2()`][Self::get_physical_device_queue_family_properties2()] + #[inline] + pub unsafe fn get_physical_device_queue_family_properties2_len( + &self, + physical_device: vk::PhysicalDevice, + ) -> usize { + let mut count = 0; + (self.fp.get_physical_device_queue_family_properties2_khr)( + physical_device, + &mut count, + ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_physical_device_queue_family_properties2_len()`][Self::get_physical_device_queue_family_properties2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_queue_family_properties2( + &self, + physical_device: vk::PhysicalDevice, + out: &mut [vk::QueueFamilyProperties2KHR], + ) { + let mut count = out.len() as u32; + (self.fp.get_physical_device_queue_family_properties2_khr)( + physical_device, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + /// Retrieve the number of elements to pass to [`get_physical_device_sparse_image_format_properties2()`][Self::get_physical_device_sparse_image_format_properties2()] + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties2_len( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2KHR, + ) -> usize { + let mut count = 0; + (self + .fp + .get_physical_device_sparse_image_format_properties2_khr)( + physical_device, + format_info, + &mut count, + ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_physical_device_sparse_image_format_properties2_len()`][Self::get_physical_device_sparse_image_format_properties2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2KHR, + out: &mut [vk::SparseImageFormatProperties2KHR], + ) { + let mut count = out.len() as u32; + (self + .fp + .get_physical_device_sparse_image_format_properties2_khr)( + physical_device, + format_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrGetPhysicalDeviceProperties2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrGetPhysicalDeviceProperties2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/get_surface_capabilities2.rs b/third_party/rust/ash/src/extensions/khr/get_surface_capabilities2.rs new file mode 100644 index 0000000000..0208b7b4a5 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/get_surface_capabilities2.rs @@ -0,0 +1,84 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct GetSurfaceCapabilities2 { + fp: vk::KhrGetSurfaceCapabilities2Fn, +} + +impl GetSurfaceCapabilities2 { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::KhrGetSurfaceCapabilities2Fn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_capabilities2( + &self, + physical_device: vk::PhysicalDevice, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + ) -> VkResult { + let mut surface_capabilities = Default::default(); + (self.fp.get_physical_device_surface_capabilities2_khr)( + physical_device, + surface_info, + &mut surface_capabilities, + ) + .result_with_success(surface_capabilities) + } + + /// Retrieve the number of elements to pass to [`get_physical_device_surface_formats2()`][Self::get_physical_device_surface_formats2()] + #[inline] + pub unsafe fn get_physical_device_surface_formats2_len( + &self, + physical_device: vk::PhysicalDevice, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + ) -> VkResult { + let mut count = 0; + let err_code = (self.fp.get_physical_device_surface_formats2_khr)( + physical_device, + surface_info, + &mut count, + std::ptr::null_mut(), + ); + err_code.result_with_success(count as usize) + } + + /// + /// + /// Call [`get_physical_device_surface_formats2_len()`][Self::get_physical_device_surface_formats2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_surface_formats2( + &self, + physical_device: vk::PhysicalDevice, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + out: &mut [vk::SurfaceFormat2KHR], + ) -> VkResult<()> { + let mut count = out.len() as u32; + let err_code = (self.fp.get_physical_device_surface_formats2_khr)( + physical_device, + surface_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + err_code.result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrGetSurfaceCapabilities2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrGetSurfaceCapabilities2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/maintenance1.rs b/third_party/rust/ash/src/extensions/khr/maintenance1.rs new file mode 100644 index 0000000000..1226d31cd5 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/maintenance1.rs @@ -0,0 +1,45 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Maintenance1 { + handle: vk::Device, + fp: vk::KhrMaintenance1Fn, +} + +impl Maintenance1 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrMaintenance1Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn trim_command_pool( + &self, + command_pool: vk::CommandPool, + flags: vk::CommandPoolTrimFlagsKHR, + ) { + (self.fp.trim_command_pool_khr)(self.handle, command_pool, flags); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrMaintenance1Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrMaintenance1Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/maintenance3.rs b/third_party/rust/ash/src/extensions/khr/maintenance3.rs new file mode 100644 index 0000000000..3b22959332 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/maintenance3.rs @@ -0,0 +1,45 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Maintenance3 { + handle: vk::Device, + fp: vk::KhrMaintenance3Fn, +} + +impl Maintenance3 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrMaintenance3Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_descriptor_set_layout_support( + &self, + create_info: &vk::DescriptorSetLayoutCreateInfo, + out: &mut vk::DescriptorSetLayoutSupportKHR, + ) { + (self.fp.get_descriptor_set_layout_support_khr)(self.handle, create_info, out); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrMaintenance3Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrMaintenance3Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/maintenance4.rs b/third_party/rust/ash/src/extensions/khr/maintenance4.rs new file mode 100644 index 0000000000..003e1a9cf2 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/maintenance4.rs @@ -0,0 +1,91 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Maintenance4 { + handle: vk::Device, + fp: vk::KhrMaintenance4Fn, +} + +impl Maintenance4 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrMaintenance4Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_device_buffer_memory_requirements( + &self, + create_info: &vk::DeviceBufferMemoryRequirementsKHR, + out: &mut vk::MemoryRequirements2, + ) { + (self.fp.get_device_buffer_memory_requirements_khr)(self.handle, create_info, out) + } + + /// + #[inline] + pub unsafe fn get_device_image_memory_requirements( + &self, + create_info: &vk::DeviceImageMemoryRequirementsKHR, + out: &mut vk::MemoryRequirements2, + ) { + (self.fp.get_device_image_memory_requirements_khr)(self.handle, create_info, out) + } + + /// Retrieve the number of elements to pass to [`get_device_image_sparse_memory_requirements()`][Self::get_device_image_sparse_memory_requirements()] + #[inline] + pub unsafe fn get_device_image_sparse_memory_requirements_len( + &self, + create_info: &vk::DeviceImageMemoryRequirementsKHR, + ) -> usize { + let mut count = 0; + (self.fp.get_device_image_sparse_memory_requirements_khr)( + self.handle, + create_info, + &mut count, + std::ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_device_image_sparse_memory_requirements_len()`][Self::get_device_image_sparse_memory_requirements_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_device_image_sparse_memory_requirements( + &self, + create_info: &vk::DeviceImageMemoryRequirementsKHR, + out: &mut [vk::SparseImageMemoryRequirements2], + ) { + let mut count = out.len() as u32; + (self.fp.get_device_image_sparse_memory_requirements_khr)( + self.handle, + create_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrMaintenance4Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrMaintenance4Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/mod.rs b/third_party/rust/ash/src/extensions/khr/mod.rs new file mode 100644 index 0000000000..ea809b43da --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/mod.rs @@ -0,0 +1,75 @@ +pub use self::acceleration_structure::AccelerationStructure; +pub use self::android_surface::AndroidSurface; +pub use self::buffer_device_address::BufferDeviceAddress; +pub use self::copy_commands2::CopyCommands2; +pub use self::create_render_pass2::CreateRenderPass2; +pub use self::deferred_host_operations::DeferredHostOperations; +pub use self::device_group::DeviceGroup; +pub use self::device_group_creation::DeviceGroupCreation; +pub use self::display::Display; +pub use self::display_swapchain::DisplaySwapchain; +pub use self::draw_indirect_count::DrawIndirectCount; +pub use self::dynamic_rendering::DynamicRendering; +pub use self::external_fence_fd::ExternalFenceFd; +pub use self::external_fence_win32::ExternalFenceWin32; +pub use self::external_memory_fd::ExternalMemoryFd; +pub use self::external_memory_win32::ExternalMemoryWin32; +pub use self::external_semaphore_fd::ExternalSemaphoreFd; +pub use self::external_semaphore_win32::ExternalSemaphoreWin32; +pub use self::get_memory_requirements2::GetMemoryRequirements2; +pub use self::get_physical_device_properties2::GetPhysicalDeviceProperties2; +pub use self::get_surface_capabilities2::GetSurfaceCapabilities2; +pub use self::maintenance1::Maintenance1; +pub use self::maintenance3::Maintenance3; +pub use self::maintenance4::Maintenance4; +pub use self::pipeline_executable_properties::PipelineExecutableProperties; +pub use self::present_wait::PresentWait; +pub use self::push_descriptor::PushDescriptor; +pub use self::ray_tracing_maintenance1::RayTracingMaintenance1; +pub use self::ray_tracing_pipeline::RayTracingPipeline; +pub use self::surface::Surface; +pub use self::swapchain::Swapchain; +pub use self::synchronization2::Synchronization2; +pub use self::timeline_semaphore::TimelineSemaphore; +pub use self::wayland_surface::WaylandSurface; +pub use self::win32_surface::Win32Surface; +pub use self::xcb_surface::XcbSurface; +pub use self::xlib_surface::XlibSurface; + +mod acceleration_structure; +mod android_surface; +mod buffer_device_address; +mod copy_commands2; +mod create_render_pass2; +mod deferred_host_operations; +mod device_group; +mod device_group_creation; +mod display; +mod display_swapchain; +mod draw_indirect_count; +mod dynamic_rendering; +mod external_fence_fd; +mod external_fence_win32; +mod external_memory_fd; +mod external_memory_win32; +mod external_semaphore_fd; +mod external_semaphore_win32; +mod get_memory_requirements2; +mod get_physical_device_properties2; +mod get_surface_capabilities2; +mod maintenance1; +mod maintenance3; +mod maintenance4; +mod pipeline_executable_properties; +mod present_wait; +mod push_descriptor; +mod ray_tracing_maintenance1; +mod ray_tracing_pipeline; +mod surface; +mod swapchain; +mod synchronization2; +mod timeline_semaphore; +mod wayland_surface; +mod win32_surface; +mod xcb_surface; +mod xlib_surface; diff --git a/third_party/rust/ash/src/extensions/khr/pipeline_executable_properties.rs b/third_party/rust/ash/src/extensions/khr/pipeline_executable_properties.rs new file mode 100644 index 0000000000..68e43b4a81 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/pipeline_executable_properties.rs @@ -0,0 +1,84 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct PipelineExecutableProperties { + handle: vk::Device, + fp: vk::KhrPipelineExecutablePropertiesFn, +} + +impl PipelineExecutableProperties { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrPipelineExecutablePropertiesFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_pipeline_executable_internal_representations( + &self, + executable_info: &vk::PipelineExecutableInfoKHR, + ) -> VkResult> { + read_into_defaulted_vector(|count, data| { + (self.fp.get_pipeline_executable_internal_representations_khr)( + self.handle, + executable_info, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn get_pipeline_executable_properties( + &self, + pipeline_info: &vk::PipelineInfoKHR, + ) -> VkResult> { + read_into_defaulted_vector(|count, data| { + (self.fp.get_pipeline_executable_properties_khr)( + self.handle, + pipeline_info, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn get_pipeline_executable_statistics( + &self, + executable_info: &vk::PipelineExecutableInfoKHR, + ) -> VkResult> { + read_into_defaulted_vector(|count, data| { + (self.fp.get_pipeline_executable_statistics_khr)( + self.handle, + executable_info, + count, + data, + ) + }) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrPipelineExecutablePropertiesFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrPipelineExecutablePropertiesFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/present_wait.rs b/third_party/rust/ash/src/extensions/khr/present_wait.rs new file mode 100644 index 0000000000..4d8effe48d --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/present_wait.rs @@ -0,0 +1,47 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct PresentWait { + handle: vk::Device, + fp: vk::KhrPresentWaitFn, +} + +impl PresentWait { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrPresentWaitFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn wait_for_present( + &self, + swapchain: vk::SwapchainKHR, + present_id: u64, + timeout: u64, + ) -> VkResult<()> { + (self.fp.wait_for_present_khr)(self.handle, swapchain, present_id, timeout).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrPresentWaitFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrPresentWaitFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/push_descriptor.rs b/third_party/rust/ash/src/extensions/khr/push_descriptor.rs new file mode 100644 index 0000000000..22d1572883 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/push_descriptor.rs @@ -0,0 +1,68 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::c_void; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct PushDescriptor { + fp: vk::KhrPushDescriptorFn, +} + +impl PushDescriptor { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrPushDescriptorFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_push_descriptor_set( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + layout: vk::PipelineLayout, + set: u32, + descriptor_writes: &[vk::WriteDescriptorSet], + ) { + (self.fp.cmd_push_descriptor_set_khr)( + command_buffer, + pipeline_bind_point, + layout, + set, + descriptor_writes.len() as u32, + descriptor_writes.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_push_descriptor_set_with_template( + &self, + command_buffer: vk::CommandBuffer, + descriptor_update_template: vk::DescriptorUpdateTemplate, + layout: vk::PipelineLayout, + set: u32, + p_data: *const c_void, + ) { + (self.fp.cmd_push_descriptor_set_with_template_khr)( + command_buffer, + descriptor_update_template, + layout, + set, + p_data, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrPushDescriptorFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrPushDescriptorFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/ray_tracing_maintenance1.rs b/third_party/rust/ash/src/extensions/khr/ray_tracing_maintenance1.rs new file mode 100644 index 0000000000..a5159ad395 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/ray_tracing_maintenance1.rs @@ -0,0 +1,42 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct RayTracingMaintenance1 { + fp: vk::KhrRayTracingMaintenance1Fn, +} + +impl RayTracingMaintenance1 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrRayTracingMaintenance1Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { fp } + } + + /// + /// + /// `indirect_device_address` is a buffer device address which is a pointer to a [`vk::TraceRaysIndirectCommand2KHR`] structure containing the trace ray parameters. + #[inline] + pub unsafe fn cmd_trace_rays_indirect2( + &self, + command_buffer: vk::CommandBuffer, + indirect_device_address: vk::DeviceAddress, + ) { + (self.fp.cmd_trace_rays_indirect2_khr)(command_buffer, indirect_device_address); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrRayTracingMaintenance1Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrRayTracingMaintenance1Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/ray_tracing_pipeline.rs b/third_party/rust/ash/src/extensions/khr/ray_tracing_pipeline.rs new file mode 100644 index 0000000000..af733430d1 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/ray_tracing_pipeline.rs @@ -0,0 +1,194 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct RayTracingPipeline { + handle: vk::Device, + fp: vk::KhrRayTracingPipelineFn, +} + +impl RayTracingPipeline { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrRayTracingPipelineFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + #[inline] + pub unsafe fn get_properties( + instance: &Instance, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceRayTracingPipelinePropertiesKHR { + let mut props_rt = vk::PhysicalDeviceRayTracingPipelinePropertiesKHR::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_rt + } + + /// + #[inline] + pub unsafe fn cmd_trace_rays( + &self, + command_buffer: vk::CommandBuffer, + raygen_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR, + miss_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR, + hit_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR, + callable_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR, + width: u32, + height: u32, + depth: u32, + ) { + (self.fp.cmd_trace_rays_khr)( + command_buffer, + raygen_shader_binding_tables, + miss_shader_binding_tables, + hit_shader_binding_tables, + callable_shader_binding_tables, + width, + height, + depth, + ); + } + + /// + #[inline] + pub unsafe fn create_ray_tracing_pipelines( + &self, + deferred_operation: vk::DeferredOperationKHR, + pipeline_cache: vk::PipelineCache, + create_info: &[vk::RayTracingPipelineCreateInfoKHR], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult> { + let mut pipelines = vec![mem::zeroed(); create_info.len()]; + (self.fp.create_ray_tracing_pipelines_khr)( + self.handle, + deferred_operation, + pipeline_cache, + create_info.len() as u32, + create_info.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ) + .result_with_success(pipelines) + } + + /// + #[inline] + pub unsafe fn get_ray_tracing_shader_group_handles( + &self, + pipeline: vk::Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + ) -> VkResult> { + let mut data = Vec::::with_capacity(data_size); + (self.fp.get_ray_tracing_shader_group_handles_khr)( + self.handle, + pipeline, + first_group, + group_count, + data_size, + data.as_mut_ptr().cast(), + ) + .result()?; + data.set_len(data_size); + Ok(data) + } + + /// + #[inline] + pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles( + &self, + pipeline: vk::Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + ) -> VkResult> { + let mut data = Vec::::with_capacity(data_size); + (self + .fp + .get_ray_tracing_capture_replay_shader_group_handles_khr)( + self.handle, + pipeline, + first_group, + group_count, + data_size, + data.as_mut_ptr().cast(), + ) + .result()?; + data.set_len(data_size); + Ok(data) + } + + /// + /// + /// `indirect_device_address` is a buffer device address which is a pointer to a [`vk::TraceRaysIndirectCommandKHR`] structure containing the trace ray parameters. + #[inline] + pub unsafe fn cmd_trace_rays_indirect( + &self, + command_buffer: vk::CommandBuffer, + raygen_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + miss_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + hit_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + callable_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + indirect_device_address: vk::DeviceAddress, + ) { + (self.fp.cmd_trace_rays_indirect_khr)( + command_buffer, + raygen_shader_binding_table.as_ptr(), + miss_shader_binding_table.as_ptr(), + hit_shader_binding_table.as_ptr(), + callable_shader_binding_table.as_ptr(), + indirect_device_address, + ); + } + + /// + #[inline] + pub unsafe fn get_ray_tracing_shader_group_stack_size( + &self, + pipeline: vk::Pipeline, + group: u32, + group_shader: vk::ShaderGroupShaderKHR, + ) -> vk::DeviceSize { + (self.fp.get_ray_tracing_shader_group_stack_size_khr)( + self.handle, + pipeline, + group, + group_shader, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size( + &self, + command_buffer: vk::CommandBuffer, + pipeline_stack_size: u32, + ) { + (self.fp.cmd_set_ray_tracing_pipeline_stack_size_khr)(command_buffer, pipeline_stack_size); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrRayTracingPipelineFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrRayTracingPipelineFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/surface.rs b/third_party/rust/ash/src/extensions/khr/surface.rs new file mode 100755 index 0000000000..11508bdcc9 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/surface.rs @@ -0,0 +1,110 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Surface { + handle: vk::Instance, + fp: vk::KhrSurfaceFn, +} + +impl Surface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut b = 0; + (self.fp.get_physical_device_surface_support_khr)( + physical_device, + queue_family_index, + surface, + &mut b, + ) + .result_with_success(b > 0) + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_present_modes( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_surface_present_modes_khr)( + physical_device, + surface, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_capabilities( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut surface_capabilities = mem::zeroed(); + (self.fp.get_physical_device_surface_capabilities_khr)( + physical_device, + surface, + &mut surface_capabilities, + ) + .result_with_success(surface_capabilities) + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_formats( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_surface_formats_khr)(physical_device, surface, count, data) + }) + } + + /// + #[inline] + pub unsafe fn destroy_surface( + &self, + surface: vk::SurfaceKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_surface_khr)(self.handle, surface, allocation_callbacks.as_raw_ptr()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/swapchain.rs b/third_party/rust/ash/src/extensions/khr/swapchain.rs new file mode 100755 index 0000000000..8f57729de7 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/swapchain.rs @@ -0,0 +1,211 @@ +#[cfg(doc)] +use super::DeviceGroup; +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Swapchain { + handle: vk::Device, + fp: vk::KhrSwapchainFn, +} + +impl Swapchain { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrSwapchainFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_swapchain( + &self, + create_info: &vk::SwapchainCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut swapchain = mem::zeroed(); + (self.fp.create_swapchain_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut swapchain, + ) + .result_with_success(swapchain) + } + + /// + #[inline] + pub unsafe fn destroy_swapchain( + &self, + swapchain: vk::SwapchainKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_swapchain_khr)(self.handle, swapchain, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn get_swapchain_images( + &self, + swapchain: vk::SwapchainKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_swapchain_images_khr)(self.handle, swapchain, count, data) + }) + } + + /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface. + /// + /// + #[inline] + pub unsafe fn acquire_next_image( + &self, + swapchain: vk::SwapchainKHR, + timeout: u64, + semaphore: vk::Semaphore, + fence: vk::Fence, + ) -> VkResult<(u32, bool)> { + let mut index = 0; + let err_code = (self.fp.acquire_next_image_khr)( + self.handle, + swapchain, + timeout, + semaphore, + fence, + &mut index, + ); + match err_code { + vk::Result::SUCCESS => Ok((index, false)), + vk::Result::SUBOPTIMAL_KHR => Ok((index, true)), + _ => Err(err_code), + } + } + + /// On success, returns whether the swapchain is suboptimal for the surface. + /// + /// + #[inline] + pub unsafe fn queue_present( + &self, + queue: vk::Queue, + present_info: &vk::PresentInfoKHR, + ) -> VkResult { + let err_code = (self.fp.queue_present_khr)(queue, present_info); + match err_code { + vk::Result::SUCCESS => Ok(false), + vk::Result::SUBOPTIMAL_KHR => Ok(true), + _ => Err(err_code), + } + } + + /// Only available since [Vulkan 1.1]. + /// + /// Also available as [`DeviceGroup::get_device_group_present_capabilities()`] + /// when [`VK_KHR_surface`] is enabled. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_device_group_present_capabilities( + &self, + device_group_present_capabilities: &mut vk::DeviceGroupPresentCapabilitiesKHR, + ) -> VkResult<()> { + (self.fp.get_device_group_present_capabilities_khr)( + self.handle, + device_group_present_capabilities, + ) + .result() + } + + /// Only available since [Vulkan 1.1]. + /// + /// Also available as [`DeviceGroup::get_device_group_surface_present_modes()`] + /// when [`VK_KHR_surface`] is enabled. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_device_group_surface_present_modes( + &self, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut modes = mem::zeroed(); + (self.fp.get_device_group_surface_present_modes_khr)(self.handle, surface, &mut modes) + .result_with_success(modes) + } + + /// Only available since [Vulkan 1.1]. + /// + /// Also available as [`DeviceGroup::get_physical_device_present_rectangles()`] + /// when [`VK_KHR_surface`] is enabled. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_physical_device_present_rectangles( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + count, + data, + ) + }) + } + + /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface. + /// + /// Only available since [Vulkan 1.1]. + /// + /// Also available as [`DeviceGroup::acquire_next_image2()`] + /// when [`VK_KHR_swapchain`] is enabled. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_swapchain`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html + #[inline] + pub unsafe fn acquire_next_image2( + &self, + acquire_info: &vk::AcquireNextImageInfoKHR, + ) -> VkResult<(u32, bool)> { + let mut index = 0; + let err_code = (self.fp.acquire_next_image2_khr)(self.handle, acquire_info, &mut index); + match err_code { + vk::Result::SUCCESS => Ok((index, false)), + vk::Result::SUBOPTIMAL_KHR => Ok((index, true)), + _ => Err(err_code), + } + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrSwapchainFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrSwapchainFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/synchronization2.rs b/third_party/rust/ash/src/extensions/khr/synchronization2.rs new file mode 100644 index 0000000000..d8baefd602 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/synchronization2.rs @@ -0,0 +1,101 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Synchronization2 { + fp: vk::KhrSynchronization2Fn, +} + +impl Synchronization2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrSynchronization2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_pipeline_barrier2( + &self, + command_buffer: vk::CommandBuffer, + dependency_info: &vk::DependencyInfoKHR, + ) { + (self.fp.cmd_pipeline_barrier2_khr)(command_buffer, dependency_info) + } + + /// + #[inline] + pub unsafe fn cmd_reset_event2( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + stage_mask: vk::PipelineStageFlags2KHR, + ) { + (self.fp.cmd_reset_event2_khr)(command_buffer, event, stage_mask) + } + + /// + #[inline] + pub unsafe fn cmd_set_event2( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + dependency_info: &vk::DependencyInfoKHR, + ) { + (self.fp.cmd_set_event2_khr)(command_buffer, event, dependency_info) + } + + /// + #[inline] + pub unsafe fn cmd_wait_events2( + &self, + command_buffer: vk::CommandBuffer, + events: &[vk::Event], + dependency_infos: &[vk::DependencyInfoKHR], + ) { + assert_eq!(events.len(), dependency_infos.len()); + (self.fp.cmd_wait_events2_khr)( + command_buffer, + events.len() as u32, + events.as_ptr(), + dependency_infos.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_write_timestamp2( + &self, + command_buffer: vk::CommandBuffer, + stage: vk::PipelineStageFlags2KHR, + query_pool: vk::QueryPool, + query: u32, + ) { + (self.fp.cmd_write_timestamp2_khr)(command_buffer, stage, query_pool, query) + } + + /// + #[inline] + pub unsafe fn queue_submit2( + &self, + queue: vk::Queue, + submits: &[vk::SubmitInfo2KHR], + fence: vk::Fence, + ) -> VkResult<()> { + (self.fp.queue_submit2_khr)(queue, submits.len() as u32, submits.as_ptr(), fence).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrSynchronization2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrSynchronization2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/timeline_semaphore.rs b/third_party/rust/ash/src/extensions/khr/timeline_semaphore.rs new file mode 100644 index 0000000000..de9a492506 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/timeline_semaphore.rs @@ -0,0 +1,60 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct TimelineSemaphore { + handle: vk::Device, + fp: vk::KhrTimelineSemaphoreFn, +} + +impl TimelineSemaphore { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrTimelineSemaphoreFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_semaphore_counter_value(&self, semaphore: vk::Semaphore) -> VkResult { + let mut value = 0; + (self.fp.get_semaphore_counter_value_khr)(self.handle, semaphore, &mut value) + .result_with_success(value) + } + + /// + #[inline] + pub unsafe fn wait_semaphores( + &self, + wait_info: &vk::SemaphoreWaitInfo, + timeout: u64, + ) -> VkResult<()> { + (self.fp.wait_semaphores_khr)(self.handle, wait_info, timeout).result() + } + + /// + #[inline] + pub unsafe fn signal_semaphore(&self, signal_info: &vk::SemaphoreSignalInfo) -> VkResult<()> { + (self.fp.signal_semaphore_khr)(self.handle, signal_info).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrTimelineSemaphoreFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrTimelineSemaphoreFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/wayland_surface.rs b/third_party/rust/ash/src/extensions/khr/wayland_surface.rs new file mode 100755 index 0000000000..d51fcb9914 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/wayland_surface.rs @@ -0,0 +1,71 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct WaylandSurface { + handle: vk::Instance, + fp: vk::KhrWaylandSurfaceFn, +} + +impl WaylandSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrWaylandSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_wayland_surface( + &self, + create_info: &vk::WaylandSurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_wayland_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + /// + #[inline] + pub unsafe fn get_physical_device_wayland_presentation_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + wl_display: &mut vk::wl_display, + ) -> bool { + let b = (self.fp.get_physical_device_wayland_presentation_support_khr)( + physical_device, + queue_family_index, + wl_display, + ); + + b > 0 + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrWaylandSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrWaylandSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/win32_surface.rs b/third_party/rust/ash/src/extensions/khr/win32_surface.rs new file mode 100755 index 0000000000..be56a02e2e --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/win32_surface.rs @@ -0,0 +1,69 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Win32Surface { + handle: vk::Instance, + fp: vk::KhrWin32SurfaceFn, +} + +impl Win32Surface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrWin32SurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_win32_surface( + &self, + create_info: &vk::Win32SurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_win32_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + /// + #[inline] + pub unsafe fn get_physical_device_win32_presentation_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + ) -> bool { + let b = (self.fp.get_physical_device_win32_presentation_support_khr)( + physical_device, + queue_family_index, + ); + + b > 0 + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrWin32SurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrWin32SurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/xcb_surface.rs b/third_party/rust/ash/src/extensions/khr/xcb_surface.rs new file mode 100755 index 0000000000..967376e7c6 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/xcb_surface.rs @@ -0,0 +1,73 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct XcbSurface { + handle: vk::Instance, + fp: vk::KhrXcbSurfaceFn, +} + +impl XcbSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrXcbSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_xcb_surface( + &self, + create_info: &vk::XcbSurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_xcb_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + /// + #[inline] + pub unsafe fn get_physical_device_xcb_presentation_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + connection: &mut vk::xcb_connection_t, + visual_id: vk::xcb_visualid_t, + ) -> bool { + let b = (self.fp.get_physical_device_xcb_presentation_support_khr)( + physical_device, + queue_family_index, + connection, + visual_id, + ); + + b > 0 + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrXcbSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrXcbSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/xlib_surface.rs b/third_party/rust/ash/src/extensions/khr/xlib_surface.rs new file mode 100755 index 0000000000..59ad416e47 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/xlib_surface.rs @@ -0,0 +1,73 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct XlibSurface { + handle: vk::Instance, + fp: vk::KhrXlibSurfaceFn, +} + +impl XlibSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrXlibSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_xlib_surface( + &self, + create_info: &vk::XlibSurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_xlib_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + /// + #[inline] + pub unsafe fn get_physical_device_xlib_presentation_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + display: &mut vk::Display, + visual_id: vk::VisualID, + ) -> bool { + let b = (self.fp.get_physical_device_xlib_presentation_support_khr)( + physical_device, + queue_family_index, + display, + visual_id, + ); + + b > 0 + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrXlibSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrXlibSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/mod.rs b/third_party/rust/ash/src/extensions/mod.rs new file mode 100644 index 0000000000..fefba9b688 --- /dev/null +++ b/third_party/rust/ash/src/extensions/mod.rs @@ -0,0 +1,6 @@ +pub mod experimental; +pub mod ext; +pub mod khr; +pub mod mvk; +pub mod nn; +pub mod nv; diff --git a/third_party/rust/ash/src/extensions/mvk/ios_surface.rs b/third_party/rust/ash/src/extensions/mvk/ios_surface.rs new file mode 100755 index 0000000000..8ae83e98d2 --- /dev/null +++ b/third_party/rust/ash/src/extensions/mvk/ios_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct IOSSurface { + handle: vk::Instance, + fp: vk::MvkIosSurfaceFn, +} + +impl IOSSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::MvkIosSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_ios_surface( + &self, + create_info: &vk::IOSSurfaceCreateInfoMVK, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_ios_surface_mvk)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::MvkIosSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::MvkIosSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/mvk/macos_surface.rs b/third_party/rust/ash/src/extensions/mvk/macos_surface.rs new file mode 100755 index 0000000000..878829e452 --- /dev/null +++ b/third_party/rust/ash/src/extensions/mvk/macos_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct MacOSSurface { + handle: vk::Instance, + fp: vk::MvkMacosSurfaceFn, +} + +impl MacOSSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::MvkMacosSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_mac_os_surface( + &self, + create_info: &vk::MacOSSurfaceCreateInfoMVK, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_mac_os_surface_mvk)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::MvkMacosSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::MvkMacosSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/mvk/mod.rs b/third_party/rust/ash/src/extensions/mvk/mod.rs new file mode 100644 index 0000000000..e475d53563 --- /dev/null +++ b/third_party/rust/ash/src/extensions/mvk/mod.rs @@ -0,0 +1,5 @@ +pub use self::ios_surface::IOSSurface; +pub use self::macos_surface::MacOSSurface; + +mod ios_surface; +mod macos_surface; diff --git a/third_party/rust/ash/src/extensions/nn/mod.rs b/third_party/rust/ash/src/extensions/nn/mod.rs new file mode 100644 index 0000000000..e429050a6c --- /dev/null +++ b/third_party/rust/ash/src/extensions/nn/mod.rs @@ -0,0 +1,3 @@ +pub use self::vi_surface::ViSurface; + +mod vi_surface; diff --git a/third_party/rust/ash/src/extensions/nn/vi_surface.rs b/third_party/rust/ash/src/extensions/nn/vi_surface.rs new file mode 100644 index 0000000000..0aa188ac27 --- /dev/null +++ b/third_party/rust/ash/src/extensions/nn/vi_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ViSurface { + handle: vk::Instance, + fp: vk::NnViSurfaceFn, +} + +impl ViSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::NnViSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_vi_surface( + &self, + create_info: &vk::ViSurfaceCreateInfoNN, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_vi_surface_nn)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NnViSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NnViSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/nv/coverage_reduction_mode.rs b/third_party/rust/ash/src/extensions/nv/coverage_reduction_mode.rs new file mode 100644 index 0000000000..b4304772e3 --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/coverage_reduction_mode.rs @@ -0,0 +1,70 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct CoverageReductionMode { + fp: vk::NvCoverageReductionModeFn, +} + +impl CoverageReductionMode { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::NvCoverageReductionModeFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// Retrieve the number of elements to pass to [`get_physical_device_supported_framebuffer_mixed_samples_combinations()`][Self::get_physical_device_supported_framebuffer_mixed_samples_combinations()] + #[inline] + pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations_len( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult { + let mut count = 0; + (self + .fp + .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)( + physical_device, + &mut count, + std::ptr::null_mut(), + ) + .result_with_success(count as usize) + } + + /// + /// + /// Call [`get_physical_device_supported_framebuffer_mixed_samples_combinations_len()`][Self::get_physical_device_supported_framebuffer_mixed_samples_combinations_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations( + &self, + physical_device: vk::PhysicalDevice, + out: &mut [vk::FramebufferMixedSamplesCombinationNV], + ) -> VkResult<()> { + let mut count = out.len() as u32; + (self + .fp + .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)( + physical_device, + &mut count, + out.as_mut_ptr(), + ) + .result()?; + assert_eq!(count as usize, out.len()); + Ok(()) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NvCoverageReductionModeFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NvCoverageReductionModeFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/nv/device_diagnostic_checkpoints.rs b/third_party/rust/ash/src/extensions/nv/device_diagnostic_checkpoints.rs new file mode 100644 index 0000000000..ce43d046e6 --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/device_diagnostic_checkpoints.rs @@ -0,0 +1,63 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::os::raw::c_void; + +/// +#[derive(Clone)] +pub struct DeviceDiagnosticCheckpoints { + fp: vk::NvDeviceDiagnosticCheckpointsFn, +} + +impl DeviceDiagnosticCheckpoints { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::NvDeviceDiagnosticCheckpointsFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_set_checkpoint( + &self, + command_buffer: vk::CommandBuffer, + p_checkpoint_marker: *const c_void, + ) { + (self.fp.cmd_set_checkpoint_nv)(command_buffer, p_checkpoint_marker); + } + + /// Retrieve the number of elements to pass to [`get_queue_checkpoint_data()`][Self::get_queue_checkpoint_data()] + #[inline] + pub unsafe fn get_queue_checkpoint_data_len(&self, queue: vk::Queue) -> usize { + let mut count = 0; + (self.fp.get_queue_checkpoint_data_nv)(queue, &mut count, std::ptr::null_mut()); + count as usize + } + + /// + /// + /// Call [`get_queue_checkpoint_data_len()`][Self::get_queue_checkpoint_data_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_queue_checkpoint_data( + &self, + queue: vk::Queue, + out: &mut [vk::CheckpointDataNV], + ) { + let mut count = out.len() as u32; + (self.fp.get_queue_checkpoint_data_nv)(queue, &mut count, out.as_mut_ptr()); + assert_eq!(count as usize, out.len()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NvDeviceDiagnosticCheckpointsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NvDeviceDiagnosticCheckpointsFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/nv/mesh_shader.rs b/third_party/rust/ash/src/extensions/nv/mesh_shader.rs new file mode 100755 index 0000000000..14ef8d44ac --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/mesh_shader.rs @@ -0,0 +1,81 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct MeshShader { + fp: vk::NvMeshShaderFn, +} + +impl MeshShader { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::NvMeshShaderFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_draw_mesh_tasks( + &self, + command_buffer: vk::CommandBuffer, + task_count: u32, + first_task: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_nv)(command_buffer, task_count, first_task); + } + + /// + #[inline] + pub unsafe fn cmd_draw_mesh_tasks_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_indirect_nv)( + command_buffer, + buffer, + offset, + draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_mesh_tasks_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_indirect_count_nv)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NvMeshShaderFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NvMeshShaderFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/nv/mod.rs b/third_party/rust/ash/src/extensions/nv/mod.rs new file mode 100644 index 0000000000..bfde37a55c --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/mod.rs @@ -0,0 +1,9 @@ +pub use self::coverage_reduction_mode::CoverageReductionMode; +pub use self::device_diagnostic_checkpoints::DeviceDiagnosticCheckpoints; +pub use self::mesh_shader::MeshShader; +pub use self::ray_tracing::RayTracing; + +mod coverage_reduction_mode; +mod device_diagnostic_checkpoints; +mod mesh_shader; +mod ray_tracing; diff --git a/third_party/rust/ash/src/extensions/nv/ray_tracing.rs b/third_party/rust/ash/src/extensions/nv/ray_tracing.rs new file mode 100755 index 0000000000..d97ec85dfe --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/ray_tracing.rs @@ -0,0 +1,271 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct RayTracing { + handle: vk::Device, + fp: vk::NvRayTracingFn, +} + +impl RayTracing { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::NvRayTracingFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + #[inline] + pub unsafe fn get_properties( + instance: &Instance, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceRayTracingPropertiesNV { + let mut props_rt = vk::PhysicalDeviceRayTracingPropertiesNV::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_rt + } + + /// + #[inline] + pub unsafe fn create_acceleration_structure( + &self, + create_info: &vk::AccelerationStructureCreateInfoNV, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut accel_struct = mem::zeroed(); + (self.fp.create_acceleration_structure_nv)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut accel_struct, + ) + .result_with_success(accel_struct) + } + + /// + #[inline] + pub unsafe fn destroy_acceleration_structure( + &self, + accel_struct: vk::AccelerationStructureNV, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_acceleration_structure_nv)( + self.handle, + accel_struct, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_memory_requirements( + &self, + info: &vk::AccelerationStructureMemoryRequirementsInfoNV, + ) -> vk::MemoryRequirements2KHR { + let mut requirements = mem::zeroed(); + (self.fp.get_acceleration_structure_memory_requirements_nv)( + self.handle, + info, + &mut requirements, + ); + requirements + } + + /// + #[inline] + pub unsafe fn bind_acceleration_structure_memory( + &self, + bind_info: &[vk::BindAccelerationStructureMemoryInfoNV], + ) -> VkResult<()> { + (self.fp.bind_acceleration_structure_memory_nv)( + self.handle, + bind_info.len() as u32, + bind_info.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_build_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::AccelerationStructureInfoNV, + instance_data: vk::Buffer, + instance_offset: vk::DeviceSize, + update: bool, + dst: vk::AccelerationStructureNV, + src: vk::AccelerationStructureNV, + scratch: vk::Buffer, + scratch_offset: vk::DeviceSize, + ) { + (self.fp.cmd_build_acceleration_structure_nv)( + command_buffer, + info, + instance_data, + instance_offset, + if update { vk::TRUE } else { vk::FALSE }, + dst, + src, + scratch, + scratch_offset, + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + dst: vk::AccelerationStructureNV, + src: vk::AccelerationStructureNV, + mode: vk::CopyAccelerationStructureModeNV, + ) { + (self.fp.cmd_copy_acceleration_structure_nv)(command_buffer, dst, src, mode); + } + + /// + #[inline] + pub unsafe fn cmd_trace_rays( + &self, + command_buffer: vk::CommandBuffer, + raygen_shader_binding_table_buffer: vk::Buffer, + raygen_shader_binding_offset: vk::DeviceSize, + miss_shader_binding_table_buffer: vk::Buffer, + miss_shader_binding_offset: vk::DeviceSize, + miss_shader_binding_stride: vk::DeviceSize, + hit_shader_binding_table_buffer: vk::Buffer, + hit_shader_binding_offset: vk::DeviceSize, + hit_shader_binding_stride: vk::DeviceSize, + callable_shader_binding_table_buffer: vk::Buffer, + callable_shader_binding_offset: vk::DeviceSize, + callable_shader_binding_stride: vk::DeviceSize, + width: u32, + height: u32, + depth: u32, + ) { + (self.fp.cmd_trace_rays_nv)( + command_buffer, + raygen_shader_binding_table_buffer, + raygen_shader_binding_offset, + miss_shader_binding_table_buffer, + miss_shader_binding_offset, + miss_shader_binding_stride, + hit_shader_binding_table_buffer, + hit_shader_binding_offset, + hit_shader_binding_stride, + callable_shader_binding_table_buffer, + callable_shader_binding_offset, + callable_shader_binding_stride, + width, + height, + depth, + ); + } + + /// + #[inline] + pub unsafe fn create_ray_tracing_pipelines( + &self, + pipeline_cache: vk::PipelineCache, + create_info: &[vk::RayTracingPipelineCreateInfoNV], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult> { + let mut pipelines = vec![mem::zeroed(); create_info.len()]; + (self.fp.create_ray_tracing_pipelines_nv)( + self.handle, + pipeline_cache, + create_info.len() as u32, + create_info.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ) + .result_with_success(pipelines) + } + + /// + #[inline] + pub unsafe fn get_ray_tracing_shader_group_handles( + &self, + pipeline: vk::Pipeline, + first_group: u32, + group_count: u32, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_ray_tracing_shader_group_handles_nv)( + self.handle, + pipeline, + first_group, + group_count, + data.len(), + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_handle( + &self, + accel_struct: vk::AccelerationStructureNV, + ) -> VkResult { + let mut handle: u64 = 0; + let handle_ptr: *mut u64 = &mut handle; + (self.fp.get_acceleration_structure_handle_nv)( + self.handle, + accel_struct, + std::mem::size_of::(), + handle_ptr.cast(), + ) + .result_with_success(handle) + } + + /// + #[inline] + pub unsafe fn cmd_write_acceleration_structures_properties( + &self, + command_buffer: vk::CommandBuffer, + structures: &[vk::AccelerationStructureNV], + query_type: vk::QueryType, + query_pool: vk::QueryPool, + first_query: u32, + ) { + (self.fp.cmd_write_acceleration_structures_properties_nv)( + command_buffer, + structures.len() as u32, + structures.as_ptr(), + query_type, + query_pool, + first_query, + ); + } + + /// + #[inline] + pub unsafe fn compile_deferred(&self, pipeline: vk::Pipeline, shader: u32) -> VkResult<()> { + (self.fp.compile_deferred_nv)(self.handle, pipeline, shader).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NvRayTracingFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NvRayTracingFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/instance.rs b/third_party/rust/ash/src/instance.rs new file mode 100644 index 0000000000..8e3bd1a8b9 --- /dev/null +++ b/third_party/rust/ash/src/instance.rs @@ -0,0 +1,535 @@ +use crate::device::Device; +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use std::mem; +use std::os::raw::c_char; +use std::ptr; + +/// +#[derive(Clone)] +pub struct Instance { + pub(crate) handle: vk::Instance, + + pub(crate) instance_fn_1_0: vk::InstanceFnV1_0, + pub(crate) instance_fn_1_1: vk::InstanceFnV1_1, + pub(crate) instance_fn_1_2: vk::InstanceFnV1_2, + pub(crate) instance_fn_1_3: vk::InstanceFnV1_3, +} + +impl Instance { + pub unsafe fn load(static_fn: &vk::StaticFn, instance: vk::Instance) -> Self { + let load_fn = |name: &std::ffi::CStr| { + mem::transmute((static_fn.get_instance_proc_addr)(instance, name.as_ptr())) + }; + + Self { + handle: instance, + + instance_fn_1_0: vk::InstanceFnV1_0::load(load_fn), + instance_fn_1_1: vk::InstanceFnV1_1::load(load_fn), + instance_fn_1_2: vk::InstanceFnV1_2::load(load_fn), + instance_fn_1_3: vk::InstanceFnV1_3::load(load_fn), + } + } + + #[inline] + pub fn handle(&self) -> vk::Instance { + self.handle + } +} + +/// Vulkan core 1.3 +#[allow(non_camel_case_types)] +impl Instance { + #[inline] + pub fn fp_v1_3(&self) -> &vk::InstanceFnV1_3 { + &self.instance_fn_1_3 + } + + /// Retrieve the number of elements to pass to [`get_physical_device_tool_properties()`][Self::get_physical_device_tool_properties()] + #[inline] + pub unsafe fn get_physical_device_tool_properties_len( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult { + let mut count = 0; + (self.instance_fn_1_3.get_physical_device_tool_properties)( + physical_device, + &mut count, + ptr::null_mut(), + ) + .result_with_success(count as usize) + } + + /// + /// + /// Call [`get_physical_device_tool_properties_len()`][Self::get_physical_device_tool_properties_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_tool_properties( + &self, + physical_device: vk::PhysicalDevice, + out: &mut [vk::PhysicalDeviceToolProperties], + ) -> VkResult<()> { + let mut count = out.len() as u32; + (self.instance_fn_1_3.get_physical_device_tool_properties)( + physical_device, + &mut count, + out.as_mut_ptr(), + ) + .result()?; + assert_eq!(count as usize, out.len()); + Ok(()) + } +} + +/// Vulkan core 1.2 +#[allow(non_camel_case_types)] +impl Instance { + #[inline] + pub fn fp_v1_2(&self) -> &vk::InstanceFnV1_2 { + &self.instance_fn_1_2 + } +} + +/// Vulkan core 1.1 +#[allow(non_camel_case_types)] +impl Instance { + #[inline] + pub fn fp_v1_1(&self) -> &vk::InstanceFnV1_1 { + &self.instance_fn_1_1 + } + + /// Retrieve the number of elements to pass to [`enumerate_physical_device_groups()`][Self::enumerate_physical_device_groups()] + #[inline] + pub unsafe fn enumerate_physical_device_groups_len(&self) -> VkResult { + let mut group_count = 0; + (self.instance_fn_1_1.enumerate_physical_device_groups)( + self.handle(), + &mut group_count, + ptr::null_mut(), + ) + .result_with_success(group_count as usize) + } + + /// + /// + /// Call [`enumerate_physical_device_groups_len()`][Self::enumerate_physical_device_groups_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn enumerate_physical_device_groups( + &self, + out: &mut [vk::PhysicalDeviceGroupProperties], + ) -> VkResult<()> { + let mut count = out.len() as u32; + (self.instance_fn_1_1.enumerate_physical_device_groups)( + self.handle(), + &mut count, + out.as_mut_ptr(), + ) + .result()?; + assert_eq!(count as usize, out.len()); + Ok(()) + } + + /// + #[inline] + pub unsafe fn get_physical_device_features2( + &self, + physical_device: vk::PhysicalDevice, + features: &mut vk::PhysicalDeviceFeatures2, + ) { + (self.instance_fn_1_1.get_physical_device_features2)(physical_device, features); + } + + /// + #[inline] + pub unsafe fn get_physical_device_properties2( + &self, + physical_device: vk::PhysicalDevice, + prop: &mut vk::PhysicalDeviceProperties2, + ) { + (self.instance_fn_1_1.get_physical_device_properties2)(physical_device, prop); + } + + /// + #[inline] + pub unsafe fn get_physical_device_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + out: &mut vk::FormatProperties2, + ) { + (self.instance_fn_1_1.get_physical_device_format_properties2)(physical_device, format, out); + } + + /// + #[inline] + pub unsafe fn get_physical_device_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceImageFormatInfo2, + image_format_prop: &mut vk::ImageFormatProperties2, + ) -> VkResult<()> { + (self + .instance_fn_1_1 + .get_physical_device_image_format_properties2)( + physical_device, + format_info, + image_format_prop, + ) + .result() + } + + /// Retrieve the number of elements to pass to [`get_physical_device_queue_family_properties2()`][Self::get_physical_device_queue_family_properties2()] + #[inline] + pub unsafe fn get_physical_device_queue_family_properties2_len( + &self, + physical_device: vk::PhysicalDevice, + ) -> usize { + let mut queue_count = 0; + (self + .instance_fn_1_1 + .get_physical_device_queue_family_properties2)( + physical_device, + &mut queue_count, + ptr::null_mut(), + ); + queue_count as usize + } + + /// + /// + /// Call [`get_physical_device_queue_family_properties2_len()`][Self::get_physical_device_queue_family_properties2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_queue_family_properties2( + &self, + physical_device: vk::PhysicalDevice, + out: &mut [vk::QueueFamilyProperties2], + ) { + let mut count = out.len() as u32; + (self + .instance_fn_1_1 + .get_physical_device_queue_family_properties2)( + physical_device, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + /// + #[inline] + pub unsafe fn get_physical_device_memory_properties2( + &self, + physical_device: vk::PhysicalDevice, + out: &mut vk::PhysicalDeviceMemoryProperties2, + ) { + (self.instance_fn_1_1.get_physical_device_memory_properties2)(physical_device, out); + } + + /// Retrieve the number of elements to pass to [`get_physical_device_sparse_image_format_properties2()`][Self::get_physical_device_sparse_image_format_properties2()] + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties2_len( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, + ) -> usize { + let mut format_count = 0; + (self + .instance_fn_1_1 + .get_physical_device_sparse_image_format_properties2)( + physical_device, + format_info, + &mut format_count, + ptr::null_mut(), + ); + format_count as usize + } + + /// + /// + /// Call [`get_physical_device_sparse_image_format_properties2_len()`][Self::get_physical_device_sparse_image_format_properties2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, + out: &mut [vk::SparseImageFormatProperties2], + ) { + let mut count = out.len() as u32; + (self + .instance_fn_1_1 + .get_physical_device_sparse_image_format_properties2)( + physical_device, + format_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + /// + #[inline] + pub unsafe fn get_physical_device_external_buffer_properties( + &self, + physical_device: vk::PhysicalDevice, + external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo, + out: &mut vk::ExternalBufferProperties, + ) { + (self + .instance_fn_1_1 + .get_physical_device_external_buffer_properties)( + physical_device, + external_buffer_info, + out, + ); + } + + /// + #[inline] + pub unsafe fn get_physical_device_external_fence_properties( + &self, + physical_device: vk::PhysicalDevice, + external_fence_info: &vk::PhysicalDeviceExternalFenceInfo, + out: &mut vk::ExternalFenceProperties, + ) { + (self + .instance_fn_1_1 + .get_physical_device_external_fence_properties)( + physical_device, + external_fence_info, + out, + ); + } + + /// + #[inline] + pub unsafe fn get_physical_device_external_semaphore_properties( + &self, + physical_device: vk::PhysicalDevice, + external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo, + out: &mut vk::ExternalSemaphoreProperties, + ) { + (self + .instance_fn_1_1 + .get_physical_device_external_semaphore_properties)( + physical_device, + external_semaphore_info, + out, + ); + } +} + +/// Vulkan core 1.0 +#[allow(non_camel_case_types)] +impl Instance { + #[inline] + pub fn fp_v1_0(&self) -> &vk::InstanceFnV1_0 { + &self.instance_fn_1_0 + } + + /// + /// + /// # Safety + /// In order for the created [`Device`] to be valid for the duration of its + /// usage, the [`Instance`] this was called on must be dropped later than the + /// resulting [`Device`]. + #[inline] + pub unsafe fn create_device( + &self, + physical_device: vk::PhysicalDevice, + create_info: &vk::DeviceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut device = mem::zeroed(); + (self.instance_fn_1_0.create_device)( + physical_device, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut device, + ) + .result()?; + Ok(Device::load(&self.instance_fn_1_0, device)) + } + + /// + #[inline] + pub unsafe fn get_device_proc_addr( + &self, + device: vk::Device, + p_name: *const c_char, + ) -> vk::PFN_vkVoidFunction { + (self.instance_fn_1_0.get_device_proc_addr)(device, p_name) + } + + /// + #[inline] + pub unsafe fn destroy_instance(&self, allocation_callbacks: Option<&vk::AllocationCallbacks>) { + (self.instance_fn_1_0.destroy_instance)(self.handle(), allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn get_physical_device_format_properties( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + ) -> vk::FormatProperties { + let mut format_prop = mem::zeroed(); + (self.instance_fn_1_0.get_physical_device_format_properties)( + physical_device, + format, + &mut format_prop, + ); + format_prop + } + + /// + #[inline] + pub unsafe fn get_physical_device_image_format_properties( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + typ: vk::ImageType, + tiling: vk::ImageTiling, + usage: vk::ImageUsageFlags, + flags: vk::ImageCreateFlags, + ) -> VkResult { + let mut image_format_prop = mem::zeroed(); + (self + .instance_fn_1_0 + .get_physical_device_image_format_properties)( + physical_device, + format, + typ, + tiling, + usage, + flags, + &mut image_format_prop, + ) + .result_with_success(image_format_prop) + } + + /// + #[inline] + pub unsafe fn get_physical_device_memory_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceMemoryProperties { + let mut memory_prop = mem::zeroed(); + (self.instance_fn_1_0.get_physical_device_memory_properties)( + physical_device, + &mut memory_prop, + ); + memory_prop + } + + /// + #[inline] + pub unsafe fn get_physical_device_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceProperties { + let mut prop = mem::zeroed(); + (self.instance_fn_1_0.get_physical_device_properties)(physical_device, &mut prop); + prop + } + + /// + #[inline] + pub unsafe fn get_physical_device_queue_family_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> Vec { + read_into_uninitialized_vector(|count, data| { + (self + .instance_fn_1_0 + .get_physical_device_queue_family_properties)( + physical_device, count, data + ); + vk::Result::SUCCESS + }) + // The closure always returns SUCCESS + .unwrap() + } + + /// + #[inline] + pub unsafe fn get_physical_device_features( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceFeatures { + let mut prop = mem::zeroed(); + (self.instance_fn_1_0.get_physical_device_features)(physical_device, &mut prop); + prop + } + + /// + #[inline] + pub unsafe fn enumerate_physical_devices(&self) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.instance_fn_1_0.enumerate_physical_devices)(self.handle(), count, data) + }) + } + + /// + #[inline] + pub unsafe fn enumerate_device_extension_properties( + &self, + device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.instance_fn_1_0.enumerate_device_extension_properties)( + device, + ptr::null(), + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn enumerate_device_layer_properties( + &self, + device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.instance_fn_1_0.enumerate_device_layer_properties)(device, count, data) + }) + } + + /// + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + typ: vk::ImageType, + samples: vk::SampleCountFlags, + usage: vk::ImageUsageFlags, + tiling: vk::ImageTiling, + ) -> Vec { + read_into_uninitialized_vector(|count, data| { + (self + .instance_fn_1_0 + .get_physical_device_sparse_image_format_properties)( + physical_device, + format, + typ, + samples, + usage, + tiling, + count, + data, + ); + vk::Result::SUCCESS + }) + // The closure always returns SUCCESS + .unwrap() + } +} diff --git a/third_party/rust/ash/src/lib.rs b/third_party/rust/ash/src/lib.rs new file mode 100644 index 0000000000..c900fc6c4d --- /dev/null +++ b/third_party/rust/ash/src/lib.rs @@ -0,0 +1,197 @@ +#![deny(clippy::use_self)] +#![warn(trivial_casts, trivial_numeric_casts)] +#![allow( + clippy::too_many_arguments, + clippy::missing_safety_doc, + clippy::upper_case_acronyms +)] +#![cfg_attr(docsrs, feature(doc_cfg))] +//! # Vulkan API +//! +//! +//! +//! ## Examples +//! +//! ```no_run +//! use ash::{vk, Entry}; +//! # fn main() -> Result<(), Box> { +//! let entry = Entry::linked(); +//! let app_info = vk::ApplicationInfo { +//! api_version: vk::make_api_version(0, 1, 0, 0), +//! ..Default::default() +//! }; +//! let create_info = vk::InstanceCreateInfo { +//! p_application_info: &app_info, +//! ..Default::default() +//! }; +//! let instance = unsafe { entry.create_instance(&create_info, None)? }; +//! # Ok(()) } +//! ``` +//! +//! ## Getting started +//! +//! Load the Vulkan library linked at compile time using [`Entry::linked()`], or load it at runtime +//! using [`Entry::load()`], which uses `libloading`. If you want to perform entry point loading +//! yourself, call [`Entry::from_static_fn()`]. +//! +//! ## Crate features +//! +//! * **debug** (default): Whether Vulkan structs should implement `Debug`. +//! * **loaded** (default): Support searching for the Vulkan loader manually at runtime. +//! * **linked**: Link the Vulkan loader at compile time. + +pub use crate::device::Device; +pub use crate::entry::Entry; +#[cfg(feature = "loaded")] +pub use crate::entry::LoadingError; +pub use crate::instance::Instance; + +mod device; +mod entry; +mod instance; +pub mod prelude; +pub mod util; +/// Raw Vulkan bindings and types, generated from `vk.xml` +#[macro_use] +pub mod vk; + +// macros of vk need to be defined beforehand +/// Wrappers for Vulkan extensions +pub mod extensions; + +pub trait RawPtr { + fn as_raw_ptr(&self) -> *const T; +} + +impl<'r, T> RawPtr for Option<&'r T> { + fn as_raw_ptr(&self) -> *const T { + match *self { + Some(inner) => inner, + _ => ::std::ptr::null(), + } + } +} + +/// Given a mutable raw pointer to a type with an `s_type` member such as [`vk::BaseOutStructure`], +/// match on a set of Vulkan structures. The struct will be rebound to the given variable of the +/// type of the given Vulkan structure. +/// +/// Note that all match bodies have to be enclosed by curly braces due to macro parsing limitations. +/// It is unfortunately not possible to write `x @ ash::vk::SomeStruct => one_line_expression(),`. +/// +/// ``` +/// let mut info = ash::vk::DeviceCreateInfo::default(); +/// let info: *mut ash::vk::BaseOutStructure = <*mut _>::cast(&mut info); +/// unsafe { +/// ash::match_out_struct!(match info { +/// info @ ash::vk::DeviceQueueCreateInfo => { +/// dbg!(&info); // Unreachable +/// } +/// info @ ash::vk::DeviceCreateInfo => { +/// dbg!(&info); +/// } +/// }) +/// } +/// ``` +/// +/// In addition this macro propagates implicit return values just like normal `match` blocks, as +/// long as a default value or expression is provided in the "any" match arm +/// (`_ => { some_value() }`). For the time being said arm must be wrapped in curly braces; an +/// expression like `_ => None` is not yet supported. +/// +/// ``` +/// # let mut info = ash::vk::DeviceCreateInfo::default(); +/// # let info: *mut ash::vk::BaseOutStructure = <*mut _>::cast(&mut info); +/// let device_create_flags: Option = unsafe { +/// ash::match_out_struct!(match info { +/// info @ ash::vk::DeviceQueueCreateInfo => { +/// dbg!(&info); // Unreachable +/// Some(ash::vk::DeviceCreateFlags::empty()) +/// } +/// info @ ash::vk::DeviceCreateInfo => { +/// dbg!(&info); +/// Some(info.flags) +/// } +/// _ => { +/// None +/// } +/// }) +/// }; +/// ``` +#[macro_export] +macro_rules! match_out_struct { + (match $p:ident { $($bind:ident @ $ty:path => $body:block $(,)?)+ $(_ => $any:block $(,)?)? }) => { + match std::ptr::addr_of!((*$p).s_type).read() { + $(<$ty as $crate::vk::TaggedStructure>::STRUCTURE_TYPE => { + let $bind = $p + .cast::<$ty>() + .as_mut() + .unwrap(); + $body + }),+ + _ => { $($any)? } + } + }; +} + +/// Given an immutable raw pointer to a type with an `s_type` member such as [`vk::BaseInStructure`], +/// match on a set of Vulkan structures. The struct will be rebound to the given variable of the +/// type of the given Vulkan structure. +/// +/// Note that all match bodies have to be enclosed by curly braces due to macro parsing limitations. +/// It is unfortunately not possible to write `x @ ash::vk::SomeStruct => one_line_expression(),`. +/// +/// ``` +/// let info = ash::vk::DeviceCreateInfo::default(); +/// let info: *const ash::vk::BaseInStructure = <*const _>::cast(&info); +/// unsafe { +/// ash::match_in_struct!(match info { +/// info @ ash::vk::DeviceQueueCreateInfo => { +/// dbg!(&info); // Unreachable +/// } +/// info @ ash::vk::DeviceCreateInfo => { +/// dbg!(&info); +/// } +/// }) +/// } +/// ``` +/// +/// See the [`match_out_struct!`] documentation for an example with implicit return values. +#[macro_export] +macro_rules! match_in_struct { + (match $p:ident { $($bind:ident @ $ty:path => $body:block $(,)?)+ $(_ => $any:block $(,)?)? }) => { + match std::ptr::addr_of!((*$p).s_type).read() { + $(<$ty as $crate::vk::TaggedStructure>::STRUCTURE_TYPE => { + let $bind = $p + .cast::<$ty>() + .as_ref() + .unwrap(); + $body + }),+ + _ => { $($any)? } + } + }; +} + +#[cfg(test)] +mod tests { + use super::vk; + #[test] + fn test_ptr_chains() { + let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); + let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); + let chain = vec![ + <*mut _>::cast(&mut variable_pointers), + <*mut _>::cast(&mut corner), + ]; + let mut device_create_info = vk::DeviceCreateInfo::builder() + .push_next(&mut corner) + .push_next(&mut variable_pointers); + let chain2: Vec<*mut vk::BaseOutStructure> = unsafe { + vk::ptr_chain_iter(&mut device_create_info) + .skip(1) + .collect() + }; + assert_eq!(chain, chain2); + } +} diff --git a/third_party/rust/ash/src/prelude.rs b/third_party/rust/ash/src/prelude.rs new file mode 100644 index 0000000000..321c3aaddd --- /dev/null +++ b/third_party/rust/ash/src/prelude.rs @@ -0,0 +1,122 @@ +use std::convert::TryInto; +#[cfg(feature = "debug")] +use std::fmt; +use std::mem; + +use crate::vk; +pub type VkResult = Result; + +impl vk::Result { + #[inline] + pub fn result(self) -> VkResult<()> { + self.result_with_success(()) + } + + #[inline] + pub fn result_with_success(self, v: T) -> VkResult { + match self { + Self::SUCCESS => Ok(v), + _ => Err(self), + } + } + + #[inline] + pub unsafe fn assume_init_on_success(self, v: mem::MaybeUninit) -> VkResult { + self.result().map(move |()| v.assume_init()) + } +} + +/// Repeatedly calls `f` until it does not return [`vk::Result::INCOMPLETE`] anymore, +/// ensuring all available data has been read into the vector. +/// +/// See for example [`vkEnumerateInstanceExtensionProperties`]: the number of available +/// items may change between calls; [`vk::Result::INCOMPLETE`] is returned when the count +/// increased (and the vector is not large enough after querying the initial size), +/// requiring Ash to try again. +/// +/// [`vkEnumerateInstanceExtensionProperties`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceExtensionProperties.html +pub(crate) unsafe fn read_into_uninitialized_vector, T>( + f: impl Fn(&mut N, *mut T) -> vk::Result, +) -> VkResult> +where + >::Error: std::fmt::Debug, +{ + loop { + let mut count = N::default(); + f(&mut count, std::ptr::null_mut()).result()?; + let mut data = + Vec::with_capacity(count.try_into().expect("`N` failed to convert to `usize`")); + + let err_code = f(&mut count, data.as_mut_ptr()); + if err_code != vk::Result::INCOMPLETE { + err_code.result()?; + data.set_len(count.try_into().expect("`N` failed to convert to `usize`")); + break Ok(data); + } + } +} + +/// Repeatedly calls `f` until it does not return [`vk::Result::INCOMPLETE`] anymore, +/// ensuring all available data has been read into the vector. +/// +/// Items in the target vector are [`default()`][`Default::default()`]-initialized which +/// is required for [`vk::BaseOutStructure`]-like structs where [`vk::BaseOutStructure::s_type`] +/// needs to be a valid type and [`vk::BaseOutStructure::p_next`] a valid or +/// [`null`][`std::ptr::null_mut()`] pointer. +/// +/// See for example [`vkEnumerateInstanceExtensionProperties`]: the number of available +/// items may change between calls; [`vk::Result::INCOMPLETE`] is returned when the count +/// increased (and the vector is not large enough after querying the initial size), +/// requiring Ash to try again. +/// +/// [`vkEnumerateInstanceExtensionProperties`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceExtensionProperties.html +pub(crate) unsafe fn read_into_defaulted_vector< + N: Copy + Default + TryInto, + T: Default + Clone, +>( + f: impl Fn(&mut N, *mut T) -> vk::Result, +) -> VkResult> +where + >::Error: std::fmt::Debug, +{ + loop { + let mut count = N::default(); + f(&mut count, std::ptr::null_mut()).result()?; + let mut data = + vec![Default::default(); count.try_into().expect("`N` failed to convert to `usize`")]; + + let err_code = f(&mut count, data.as_mut_ptr()); + if err_code != vk::Result::INCOMPLETE { + data.set_len(count.try_into().expect("`N` failed to convert to `usize`")); + break err_code.result_with_success(data); + } + } +} + +#[cfg(feature = "debug")] +pub(crate) fn debug_flags + Copy>( + f: &mut fmt::Formatter, + known: &[(Value, &'static str)], + value: Value, +) -> fmt::Result { + let mut first = true; + let mut accum = value.into(); + for &(bit, name) in known { + let bit = bit.into(); + if bit != 0 && accum & bit == bit { + if !first { + f.write_str(" | ")?; + } + f.write_str(name)?; + first = false; + accum &= !bit; + } + } + if accum != 0 { + if !first { + f.write_str(" | ")?; + } + write!(f, "{:b}", accum)?; + } + Ok(()) +} diff --git a/third_party/rust/ash/src/util.rs b/third_party/rust/ash/src/util.rs new file mode 100644 index 0000000000..119fab9c65 --- /dev/null +++ b/third_party/rust/ash/src/util.rs @@ -0,0 +1,139 @@ +use crate::vk; +use std::iter::Iterator; +use std::marker::PhantomData; +use std::mem::size_of; +use std::os::raw::c_void; +use std::{io, slice}; + +/// [`Align`] handles dynamic alignment. The is useful for dynamic uniform buffers where +/// the alignment might be different. For example a 4x4 f32 matrix has a size of 64 bytes +/// but the min alignment for a dynamic uniform buffer might be 256 bytes. A slice of `&[Mat4x4]` +/// has a memory layout of `[[64 bytes], [64 bytes], [64 bytes]]`, but it might need to have a memory +/// layout of `[[256 bytes], [256 bytes], [256 bytes]]`. +/// [`Align::copy_from_slice`] will copy a slice of `&[T]` directly into the host memory without +/// an additional allocation and with the correct alignment. +#[derive(Debug, Clone)] +pub struct Align { + ptr: *mut c_void, + elem_size: vk::DeviceSize, + size: vk::DeviceSize, + _m: PhantomData, +} + +#[derive(Debug)] +pub struct AlignIter<'a, T: 'a> { + align: &'a mut Align, + current: vk::DeviceSize, +} + +impl Align { + pub fn copy_from_slice(&mut self, slice: &[T]) { + use std::slice::from_raw_parts_mut; + if self.elem_size == size_of::() as u64 { + unsafe { + let mapped_slice = from_raw_parts_mut(self.ptr.cast(), slice.len()); + mapped_slice.copy_from_slice(slice); + } + } else { + for (i, val) in self.iter_mut().enumerate().take(slice.len()) { + *val = slice[i]; + } + } + } +} + +fn calc_padding(adr: vk::DeviceSize, align: vk::DeviceSize) -> vk::DeviceSize { + (align - adr % align) % align +} + +impl Align { + pub unsafe fn new(ptr: *mut c_void, alignment: vk::DeviceSize, size: vk::DeviceSize) -> Self { + let padding = calc_padding(size_of::() as vk::DeviceSize, alignment); + let elem_size = size_of::() as vk::DeviceSize + padding; + assert!(calc_padding(size, alignment) == 0, "size must be aligned"); + Self { + ptr, + elem_size, + size, + _m: PhantomData, + } + } + + pub fn iter_mut(&mut self) -> AlignIter { + AlignIter { + current: 0, + align: self, + } + } +} + +impl<'a, T: Copy + 'a> Iterator for AlignIter<'a, T> { + type Item = &'a mut T; + fn next(&mut self) -> Option { + if self.current == self.align.size { + return None; + } + unsafe { + // Need to cast to *mut u8 because () has size 0 + let ptr = (self.align.ptr.cast::()) + .offset(self.current as isize) + .cast(); + self.current += self.align.elem_size; + Some(&mut *ptr) + } + } +} + +/// Decode SPIR-V from bytes. +/// +/// This function handles SPIR-V of arbitrary endianness gracefully, and returns correctly aligned +/// storage. +/// +/// # Examples +/// ```no_run +/// // Decode SPIR-V from a file +/// let mut file = std::fs::File::open("/path/to/shader.spv").unwrap(); +/// let words = ash::util::read_spv(&mut file).unwrap(); +/// ``` +/// ``` +/// // Decode SPIR-V from memory +/// const SPIRV: &[u8] = &[ +/// // ... +/// # 0x03, 0x02, 0x23, 0x07, +/// ]; +/// let words = ash::util::read_spv(&mut std::io::Cursor::new(&SPIRV[..])).unwrap(); +/// ``` +pub fn read_spv(x: &mut R) -> io::Result> { + let size = x.seek(io::SeekFrom::End(0))?; + if size % 4 != 0 { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "input length not divisible by 4", + )); + } + if size > usize::max_value() as u64 { + return Err(io::Error::new(io::ErrorKind::InvalidData, "input too long")); + } + let words = (size / 4) as usize; + // https://github.com/MaikKlein/ash/issues/354: + // Zero-initialize the result to prevent read_exact from possibly + // reading uninitialized memory. + let mut result = vec![0u32; words]; + x.seek(io::SeekFrom::Start(0))?; + x.read_exact(unsafe { + slice::from_raw_parts_mut(result.as_mut_ptr().cast::(), words * 4) + })?; + const MAGIC_NUMBER: u32 = 0x0723_0203; + if !result.is_empty() && result[0] == MAGIC_NUMBER.swap_bytes() { + for word in &mut result { + *word = word.swap_bytes(); + } + } + if result.is_empty() || result[0] != MAGIC_NUMBER { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "input missing SPIR-V magic number", + )); + } + Ok(result) +} diff --git a/third_party/rust/ash/src/vk.rs b/third_party/rust/ash/src/vk.rs new file mode 100644 index 0000000000..02a5e9c627 --- /dev/null +++ b/third_party/rust/ash/src/vk.rs @@ -0,0 +1,52 @@ +#![allow( + clippy::too_many_arguments, + clippy::cognitive_complexity, + clippy::wrong_self_convention +)] +#[macro_use] +mod macros; +pub use macros::*; +mod aliases; +pub use aliases::*; +mod bitflags; +pub use bitflags::*; +#[cfg(feature = "debug")] +mod const_debugs; +mod constants; +pub use constants::*; +mod definitions; +pub use definitions::*; +mod enums; +pub use enums::*; +mod extensions; +pub use extensions::*; +mod feature_extensions; +pub use feature_extensions::*; +mod features; +pub use features::*; +mod prelude; +pub use prelude::*; +/// Native bindings from Vulkan headers, generated by bindgen +#[allow(clippy::useless_transmute, nonstandard_style)] +pub mod native; +mod platform_types; +pub use platform_types::*; +/// Iterates through the pointer chain. Includes the item that is passed into the function. +/// Stops at the last [`BaseOutStructure`] that has a null [`BaseOutStructure::p_next`] field. +pub(crate) unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { + let ptr = <*mut T>::cast::(ptr); + (0..).scan(ptr, |p_ptr, _| { + if p_ptr.is_null() { + return None; + } + let n_ptr = (**p_ptr).p_next; + let old = *p_ptr; + *p_ptr = n_ptr; + Some(old) + }) +} +pub trait Handle { + const TYPE: ObjectType; + fn as_raw(self) -> u64; + fn from_raw(_: u64) -> Self; +} diff --git a/third_party/rust/ash/src/vk/aliases.rs b/third_party/rust/ash/src/vk/aliases.rs new file mode 100644 index 0000000000..1e5d20fe23 --- /dev/null +++ b/third_party/rust/ash/src/vk/aliases.rs @@ -0,0 +1,251 @@ +use crate::vk::bitflags::*; +use crate::vk::definitions::*; +use crate::vk::enums::*; +pub type GeometryFlagsNV = GeometryFlagsKHR; +pub type GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR; +pub type BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR; +pub type PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags; +pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; +pub type PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags; +pub type SemaphoreWaitFlagsKHR = SemaphoreWaitFlags; +pub type AccessFlags2KHR = AccessFlags2; +pub type PipelineStageFlags2KHR = PipelineStageFlags2; +pub type FormatFeatureFlags2KHR = FormatFeatureFlags2; +pub type RenderingFlagsKHR = RenderingFlags; +pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; +pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags; +pub type CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; +pub type ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; +pub type ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; +pub type ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; +pub type ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; +pub type SemaphoreImportFlagsKHR = SemaphoreImportFlags; +pub type ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; +pub type ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; +pub type FenceImportFlagsKHR = FenceImportFlags; +pub type DescriptorBindingFlagsEXT = DescriptorBindingFlags; +pub type ResolveModeFlagsKHR = ResolveModeFlags; +pub type ToolPurposeFlagsEXT = ToolPurposeFlags; +pub type SubmitFlagsKHR = SubmitFlags; +pub type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; +pub type SamplerYcbcrConversionKHR = SamplerYcbcrConversion; +pub type PrivateDataSlotEXT = PrivateDataSlot; +pub type DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType; +pub type PointClippingBehaviorKHR = PointClippingBehavior; +pub type QueueGlobalPriorityEXT = QueueGlobalPriorityKHR; +pub type SemaphoreTypeKHR = SemaphoreType; +pub type CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR; +pub type AccelerationStructureTypeNV = AccelerationStructureTypeKHR; +pub type GeometryTypeNV = GeometryTypeKHR; +pub type RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR; +pub type TessellationDomainOriginKHR = TessellationDomainOrigin; +pub type SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion; +pub type SamplerYcbcrRangeKHR = SamplerYcbcrRange; +pub type ChromaLocationKHR = ChromaLocation; +pub type SamplerReductionModeEXT = SamplerReductionMode; +pub type ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence; +pub type DriverIdKHR = DriverId; +pub type DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo; +pub type PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo; +pub type PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures; +pub type PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; +pub type PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; +pub type FormatProperties2KHR = FormatProperties2; +pub type ImageFormatProperties2KHR = ImageFormatProperties2; +pub type PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; +pub type QueueFamilyProperties2KHR = QueueFamilyProperties2; +pub type PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; +pub type SparseImageFormatProperties2KHR = SparseImageFormatProperties2; +pub type PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; +pub type ConformanceVersionKHR = ConformanceVersion; +pub type PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties; +pub type PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; +pub type PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; +pub type PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures; +pub type ExternalMemoryPropertiesKHR = ExternalMemoryProperties; +pub type PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; +pub type ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; +pub type PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; +pub type ExternalBufferPropertiesKHR = ExternalBufferProperties; +pub type PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; +pub type ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; +pub type ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; +pub type ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; +pub type PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; +pub type ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; +pub type ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; +pub type PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; +pub type ExternalFencePropertiesKHR = ExternalFenceProperties; +pub type ExportFenceCreateInfoKHR = ExportFenceCreateInfo; +pub type PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; +pub type PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; +pub type RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; +pub type PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; +pub type MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; +pub type BindBufferMemoryInfoKHR = BindBufferMemoryInfo; +pub type BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; +pub type BindImageMemoryInfoKHR = BindImageMemoryInfo; +pub type BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; +pub type DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; +pub type DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; +pub type DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; +pub type DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; +pub type DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; +pub type DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; +pub type DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; +pub type InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; +pub type RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; +pub type PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; +pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = + PhysicalDeviceShaderSubgroupExtendedTypesFeatures; +pub type BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; +pub type DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements; +pub type ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; +pub type ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; +pub type DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements; +pub type MemoryRequirements2KHR = MemoryRequirements2; +pub type SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; +pub type PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; +pub type MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; +pub type MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; +pub type ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; +pub type PipelineTessellationDomainOriginStateCreateInfoKHR = + PipelineTessellationDomainOriginStateCreateInfo; +pub type SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; +pub type SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; +pub type BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; +pub type ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; +pub type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = + PhysicalDeviceSamplerYcbcrConversionFeatures; +pub type SamplerYcbcrConversionImageFormatPropertiesKHR = + SamplerYcbcrConversionImageFormatProperties; +pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = + PhysicalDeviceSamplerFilterMinmaxProperties; +pub type SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo; +pub type PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures; +pub type PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties; +pub type WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock; +pub type DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo; +pub type ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo; +pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; +pub type PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features; +pub type PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties; +pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; +pub type PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; +pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; +pub type PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; +pub type PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties; +pub type PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures; +pub type DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR; +pub type PhysicalDeviceGlobalPriorityQueryFeaturesEXT = + PhysicalDeviceGlobalPriorityQueryFeaturesKHR; +pub type QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR; +pub type PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures; +pub type PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties; +pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo; +pub type DescriptorSetVariableDescriptorCountAllocateInfoEXT = + DescriptorSetVariableDescriptorCountAllocateInfo; +pub type DescriptorSetVariableDescriptorCountLayoutSupportEXT = + DescriptorSetVariableDescriptorCountLayoutSupport; +pub type AttachmentDescription2KHR = AttachmentDescription2; +pub type AttachmentReference2KHR = AttachmentReference2; +pub type SubpassDescription2KHR = SubpassDescription2; +pub type SubpassDependency2KHR = SubpassDependency2; +pub type RenderPassCreateInfo2KHR = RenderPassCreateInfo2; +pub type SubpassBeginInfoKHR = SubpassBeginInfo; +pub type SubpassEndInfoKHR = SubpassEndInfo; +pub type PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures; +pub type PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties; +pub type SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo; +pub type TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo; +pub type SemaphoreWaitInfoKHR = SemaphoreWaitInfo; +pub type SemaphoreSignalInfoKHR = SemaphoreSignalInfo; +pub type PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures; +pub type PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures; +pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features; +pub type PhysicalDeviceDepthStencilResolvePropertiesKHR = + PhysicalDeviceDepthStencilResolveProperties; +pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; +pub type PhysicalDeviceFragmentShaderBarycentricFeaturesNV = + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; +pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; +pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; +pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = + PhysicalDeviceUniformBufferStandardLayoutFeatures; +pub type PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures; +pub type PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; +pub type BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo; +pub type BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo; +pub type BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo; +pub type PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures; +pub type FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo; +pub type FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo; +pub type RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo; +pub type PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = + PhysicalDeviceTextureCompressionASTCHDRFeatures; +pub type PipelineCreationFeedbackEXT = PipelineCreationFeedback; +pub type PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo; +pub type QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL; +pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = + PhysicalDeviceSeparateDepthStencilLayoutsFeatures; +pub type AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; +pub type AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; +pub type PipelineInfoEXT = PipelineInfoKHR; +pub type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = + PhysicalDeviceShaderDemoteToHelperInvocationFeatures; +pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT = + PhysicalDeviceTexelBufferAlignmentProperties; +pub type PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures; +pub type PhysicalDeviceSubgroupSizeControlPropertiesEXT = + PhysicalDeviceSubgroupSizeControlProperties; +pub type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = + PipelineShaderStageRequiredSubgroupSizeCreateInfo; +pub type MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; +pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; +pub type PhysicalDevicePipelineCreationCacheControlFeaturesEXT = + PhysicalDevicePipelineCreationCacheControlFeatures; +pub type PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties; +pub type AabbPositionsNV = AabbPositionsKHR; +pub type TransformMatrixNV = TransformMatrixKHR; +pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; +pub type PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; +pub type PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures; +pub type BufferCopy2KHR = BufferCopy2; +pub type ImageCopy2KHR = ImageCopy2; +pub type ImageBlit2KHR = ImageBlit2; +pub type BufferImageCopy2KHR = BufferImageCopy2; +pub type ImageResolve2KHR = ImageResolve2; +pub type CopyBufferInfo2KHR = CopyBufferInfo2; +pub type CopyImageInfo2KHR = CopyImageInfo2; +pub type BlitImageInfo2KHR = BlitImageInfo2; +pub type CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2; +pub type CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2; +pub type ResolveImageInfo2KHR = ResolveImageInfo2; +pub type PhysicalDeviceShaderTerminateInvocationFeaturesKHR = + PhysicalDeviceShaderTerminateInvocationFeatures; +pub type PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = + PhysicalDeviceMutableDescriptorTypeFeaturesEXT; +pub type MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT; +pub type MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT; +pub type MemoryBarrier2KHR = MemoryBarrier2; +pub type ImageMemoryBarrier2KHR = ImageMemoryBarrier2; +pub type BufferMemoryBarrier2KHR = BufferMemoryBarrier2; +pub type DependencyInfoKHR = DependencyInfo; +pub type SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo; +pub type CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo; +pub type SubmitInfo2KHR = SubmitInfo2; +pub type PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features; +pub type PhysicalDeviceShaderIntegerDotProductFeaturesKHR = + PhysicalDeviceShaderIntegerDotProductFeatures; +pub type PhysicalDeviceShaderIntegerDotProductPropertiesKHR = + PhysicalDeviceShaderIntegerDotProductProperties; +pub type FormatProperties3KHR = FormatProperties3; +pub type PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo; +pub type RenderingInfoKHR = RenderingInfo; +pub type RenderingAttachmentInfoKHR = RenderingAttachmentInfo; +pub type PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures; +pub type CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo; +pub type AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; +pub type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; diff --git a/third_party/rust/ash/src/vk/bitflags.rs b/third_party/rust/ash/src/vk/bitflags.rs new file mode 100644 index 0000000000..66699d7214 --- /dev/null +++ b/third_party/rust/ash/src/vk/bitflags.rs @@ -0,0 +1,1643 @@ +use crate::vk::definitions::*; +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCacheCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCacheCreateFlags, Flags); +impl PipelineCacheCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueueFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueueFlags, Flags); +impl QueueFlags { + #[doc = "Queue supports graphics operations"] + pub const GRAPHICS: Self = Self(0b1); + #[doc = "Queue supports compute operations"] + pub const COMPUTE: Self = Self(0b10); + #[doc = "Queue supports transfer operations"] + pub const TRANSFER: Self = Self(0b100); + #[doc = "Queue supports sparse resource memory management operations"] + pub const SPARSE_BINDING: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CullModeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CullModeFlags, Flags); +impl CullModeFlags { + pub const NONE: Self = Self(0); + pub const FRONT: Self = Self(0b1); + pub const BACK: Self = Self(0b10); + pub const FRONT_AND_BACK: Self = Self(0x0000_0003); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct RenderPassCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(RenderPassCreateFlags, Flags); +impl RenderPassCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceQueueCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceQueueCreateFlags, Flags); +impl DeviceQueueCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryPropertyFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryPropertyFlags, Flags); +impl MemoryPropertyFlags { + #[doc = "If otherwise stated, then allocate memory on device"] + pub const DEVICE_LOCAL: Self = Self(0b1); + #[doc = "Memory is mappable by host"] + pub const HOST_VISIBLE: Self = Self(0b10); + #[doc = "Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"] + pub const HOST_COHERENT: Self = Self(0b100); + #[doc = "Memory will be cached by the host"] + pub const HOST_CACHED: Self = Self(0b1000); + #[doc = "Memory may be allocated by the driver when it is required"] + pub const LAZILY_ALLOCATED: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryHeapFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryHeapFlags, Flags); +impl MemoryHeapFlags { + #[doc = "If set, heap represents device memory"] + pub const DEVICE_LOCAL: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccessFlags(pub(crate) Flags); +vk_bitflags_wrapped!(AccessFlags, Flags); +impl AccessFlags { + #[doc = "Controls coherency of indirect command reads"] + pub const INDIRECT_COMMAND_READ: Self = Self(0b1); + #[doc = "Controls coherency of index reads"] + pub const INDEX_READ: Self = Self(0b10); + #[doc = "Controls coherency of vertex attribute reads"] + pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100); + #[doc = "Controls coherency of uniform buffer reads"] + pub const UNIFORM_READ: Self = Self(0b1000); + #[doc = "Controls coherency of input attachment reads"] + pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000); + #[doc = "Controls coherency of shader reads"] + pub const SHADER_READ: Self = Self(0b10_0000); + #[doc = "Controls coherency of shader writes"] + pub const SHADER_WRITE: Self = Self(0b100_0000); + #[doc = "Controls coherency of color attachment reads"] + pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000); + #[doc = "Controls coherency of color attachment writes"] + pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000); + #[doc = "Controls coherency of depth/stencil attachment reads"] + pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000); + #[doc = "Controls coherency of depth/stencil attachment writes"] + pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000); + #[doc = "Controls coherency of transfer reads"] + pub const TRANSFER_READ: Self = Self(0b1000_0000_0000); + #[doc = "Controls coherency of transfer writes"] + pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000); + #[doc = "Controls coherency of host reads"] + pub const HOST_READ: Self = Self(0b10_0000_0000_0000); + #[doc = "Controls coherency of host writes"] + pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000); + #[doc = "Controls coherency of memory reads"] + pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000); + #[doc = "Controls coherency of memory writes"] + pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BufferUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(BufferUsageFlags, Flags); +impl BufferUsageFlags { + #[doc = "Can be used as a source of transfer operations"] + pub const TRANSFER_SRC: Self = Self(0b1); + #[doc = "Can be used as a destination of transfer operations"] + pub const TRANSFER_DST: Self = Self(0b10); + #[doc = "Can be used as TBO"] + pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b100); + #[doc = "Can be used as IBO"] + pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1000); + #[doc = "Can be used as UBO"] + pub const UNIFORM_BUFFER: Self = Self(0b1_0000); + #[doc = "Can be used as SSBO"] + pub const STORAGE_BUFFER: Self = Self(0b10_0000); + #[doc = "Can be used as source of fixed-function index fetch (index buffer)"] + pub const INDEX_BUFFER: Self = Self(0b100_0000); + #[doc = "Can be used as source of fixed-function vertex fetch (VBO)"] + pub const VERTEX_BUFFER: Self = Self(0b1000_0000); + #[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"] + pub const INDIRECT_BUFFER: Self = Self(0b1_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BufferCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(BufferCreateFlags, Flags); +impl BufferCreateFlags { + #[doc = "Buffer should support sparse backing"] + pub const SPARSE_BINDING: Self = Self(0b1); + #[doc = "Buffer should support sparse backing with partial residency"] + pub const SPARSE_RESIDENCY: Self = Self(0b10); + #[doc = "Buffer should support constant data access to physical memory ranges mapped into multiple locations of sparse buffers"] + pub const SPARSE_ALIASED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ShaderStageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ShaderStageFlags, Flags); +impl ShaderStageFlags { + pub const VERTEX: Self = Self(0b1); + pub const TESSELLATION_CONTROL: Self = Self(0b10); + pub const TESSELLATION_EVALUATION: Self = Self(0b100); + pub const GEOMETRY: Self = Self(0b1000); + pub const FRAGMENT: Self = Self(0b1_0000); + pub const COMPUTE: Self = Self(0b10_0000); + pub const ALL_GRAPHICS: Self = Self(0x0000_001F); + pub const ALL: Self = Self(0x7FFF_FFFF); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageUsageFlags, Flags); +impl ImageUsageFlags { + #[doc = "Can be used as a source of transfer operations"] + pub const TRANSFER_SRC: Self = Self(0b1); + #[doc = "Can be used as a destination of transfer operations"] + pub const TRANSFER_DST: Self = Self(0b10); + #[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] + pub const SAMPLED: Self = Self(0b100); + #[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"] + pub const STORAGE: Self = Self(0b1000); + #[doc = "Can be used as framebuffer color attachment"] + pub const COLOR_ATTACHMENT: Self = Self(0b1_0000); + #[doc = "Can be used as framebuffer depth/stencil attachment"] + pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000); + #[doc = "Image data not needed outside of rendering"] + pub const TRANSIENT_ATTACHMENT: Self = Self(0b100_0000); + #[doc = "Can be used as framebuffer input attachment"] + pub const INPUT_ATTACHMENT: Self = Self(0b1000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCreateFlags, Flags); +impl ImageCreateFlags { + #[doc = "Image should support sparse backing"] + pub const SPARSE_BINDING: Self = Self(0b1); + #[doc = "Image should support sparse backing with partial residency"] + pub const SPARSE_RESIDENCY: Self = Self(0b10); + #[doc = "Image should support constant data access to physical memory ranges mapped into multiple locations of sparse images"] + pub const SPARSE_ALIASED: Self = Self(0b100); + #[doc = "Allows image views to have different format than the base image"] + pub const MUTABLE_FORMAT: Self = Self(0b1000); + #[doc = "Allows creating image views with cube type from the created image"] + pub const CUBE_COMPATIBLE: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageViewCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageViewCreateFlags, Flags); +impl ImageViewCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SamplerCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SamplerCreateFlags, Flags); +impl SamplerCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCreateFlags, Flags); +impl PipelineCreateFlags { + pub const DISABLE_OPTIMIZATION: Self = Self(0b1); + pub const ALLOW_DERIVATIVES: Self = Self(0b10); + pub const DERIVATIVE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineShaderStageCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, Flags); +impl PipelineShaderStageCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ColorComponentFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ColorComponentFlags, Flags); +impl ColorComponentFlags { + pub const R: Self = Self(0b1); + pub const G: Self = Self(0b10); + pub const B: Self = Self(0b100); + pub const A: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FenceCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FenceCreateFlags, Flags); +impl FenceCreateFlags { + pub const SIGNALED: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SemaphoreCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SemaphoreCreateFlags, Flags); +impl SemaphoreCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FormatFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FormatFeatureFlags, Flags); +impl FormatFeatureFlags { + #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] + pub const SAMPLED_IMAGE: Self = Self(0b1); + #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"] + pub const STORAGE_IMAGE: Self = Self(0b10); + #[doc = "Format supports atomic operations in case it is used for storage images"] + pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); + #[doc = "Format can be used for uniform texel buffers (TBOs)"] + pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); + #[doc = "Format can be used for storage texel buffers (IBOs)"] + pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); + #[doc = "Format supports atomic operations in case it is used for storage texel buffers"] + pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); + #[doc = "Format can be used for vertex buffers (VBOs)"] + pub const VERTEX_BUFFER: Self = Self(0b100_0000); + #[doc = "Format can be used for color attachment images"] + pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); + #[doc = "Format supports blending in case it is used for color attachment images"] + pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); + #[doc = "Format can be used for depth/stencil attachment images"] + pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); + #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"] + pub const BLIT_SRC: Self = Self(0b100_0000_0000); + #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"] + pub const BLIT_DST: Self = Self(0b1000_0000_0000); + #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] + pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueryControlFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryControlFlags, Flags); +impl QueryControlFlags { + #[doc = "Require precise results to be collected by the query"] + pub const PRECISE: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueryResultFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryResultFlags, Flags); +impl QueryResultFlags { + #[doc = "Results of the queries are written to the destination buffer as 64-bit values"] + pub const TYPE_64: Self = Self(0b1); + #[doc = "Results of the queries are waited on before proceeding with the result copy"] + pub const WAIT: Self = Self(0b10); + #[doc = "Besides the results of the query, the availability of the results is also written"] + pub const WITH_AVAILABILITY: Self = Self(0b100); + #[doc = "Copy the partial results of the query even if the final results are not available"] + pub const PARTIAL: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandBufferUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandBufferUsageFlags, Flags); +impl CommandBufferUsageFlags { + pub const ONE_TIME_SUBMIT: Self = Self(0b1); + pub const RENDER_PASS_CONTINUE: Self = Self(0b10); + #[doc = "Command buffer may be submitted/executed more than once simultaneously"] + pub const SIMULTANEOUS_USE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueryPipelineStatisticFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryPipelineStatisticFlags, Flags); +impl QueryPipelineStatisticFlags { + #[doc = "Optional"] + pub const INPUT_ASSEMBLY_VERTICES: Self = Self(0b1); + #[doc = "Optional"] + pub const INPUT_ASSEMBLY_PRIMITIVES: Self = Self(0b10); + #[doc = "Optional"] + pub const VERTEX_SHADER_INVOCATIONS: Self = Self(0b100); + #[doc = "Optional"] + pub const GEOMETRY_SHADER_INVOCATIONS: Self = Self(0b1000); + #[doc = "Optional"] + pub const GEOMETRY_SHADER_PRIMITIVES: Self = Self(0b1_0000); + #[doc = "Optional"] + pub const CLIPPING_INVOCATIONS: Self = Self(0b10_0000); + #[doc = "Optional"] + pub const CLIPPING_PRIMITIVES: Self = Self(0b100_0000); + #[doc = "Optional"] + pub const FRAGMENT_SHADER_INVOCATIONS: Self = Self(0b1000_0000); + #[doc = "Optional"] + pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = Self(0b1_0000_0000); + #[doc = "Optional"] + pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = Self(0b10_0000_0000); + #[doc = "Optional"] + pub const COMPUTE_SHADER_INVOCATIONS: Self = Self(0b100_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageAspectFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageAspectFlags, Flags); +impl ImageAspectFlags { + pub const COLOR: Self = Self(0b1); + pub const DEPTH: Self = Self(0b10); + pub const STENCIL: Self = Self(0b100); + pub const METADATA: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SparseImageFormatFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SparseImageFormatFlags, Flags); +impl SparseImageFormatFlags { + #[doc = "Image uses a single mip tail region for all array layers"] + pub const SINGLE_MIPTAIL: Self = Self(0b1); + #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."] + pub const ALIGNED_MIP_SIZE: Self = Self(0b10); + #[doc = "Image uses a non-standard sparse image block dimensions"] + pub const NONSTANDARD_BLOCK_SIZE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SparseMemoryBindFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SparseMemoryBindFlags, Flags); +impl SparseMemoryBindFlags { + #[doc = "Operation binds resource metadata to memory"] + pub const METADATA: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineStageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineStageFlags, Flags); +impl PipelineStageFlags { + #[doc = "Before subsequent commands are processed"] + pub const TOP_OF_PIPE: Self = Self(0b1); + #[doc = "Draw/DispatchIndirect command fetch"] + pub const DRAW_INDIRECT: Self = Self(0b10); + #[doc = "Vertex/index fetch"] + pub const VERTEX_INPUT: Self = Self(0b100); + #[doc = "Vertex shading"] + pub const VERTEX_SHADER: Self = Self(0b1000); + #[doc = "Tessellation control shading"] + pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); + #[doc = "Tessellation evaluation shading"] + pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); + #[doc = "Geometry shading"] + pub const GEOMETRY_SHADER: Self = Self(0b100_0000); + #[doc = "Fragment shading"] + pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); + #[doc = "Early fragment (depth and stencil) tests"] + pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); + #[doc = "Late fragment (depth and stencil) tests"] + pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); + #[doc = "Color attachment writes"] + pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); + #[doc = "Compute shading"] + pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); + #[doc = "Transfer/copy operations"] + pub const TRANSFER: Self = Self(0b1_0000_0000_0000); + #[doc = "After previous commands have completed"] + pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); + #[doc = "Indicates host (CPU) is a source/sink of the dependency"] + pub const HOST: Self = Self(0b100_0000_0000_0000); + #[doc = "All stages of the graphics pipeline"] + pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); + #[doc = "All stages supported on the queue"] + pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandPoolCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandPoolCreateFlags, Flags); +impl CommandPoolCreateFlags { + #[doc = "Command buffers have a short lifetime"] + pub const TRANSIENT: Self = Self(0b1); + #[doc = "Command buffers may release their memory individually"] + pub const RESET_COMMAND_BUFFER: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandPoolResetFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandPoolResetFlags, Flags); +impl CommandPoolResetFlags { + #[doc = "Release resources owned by the pool"] + pub const RELEASE_RESOURCES: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandBufferResetFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandBufferResetFlags, Flags); +impl CommandBufferResetFlags { + #[doc = "Release resources owned by the buffer"] + pub const RELEASE_RESOURCES: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SampleCountFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SampleCountFlags, Flags); +impl SampleCountFlags { + #[doc = "Sample count 1 supported"] + pub const TYPE_1: Self = Self(0b1); + #[doc = "Sample count 2 supported"] + pub const TYPE_2: Self = Self(0b10); + #[doc = "Sample count 4 supported"] + pub const TYPE_4: Self = Self(0b100); + #[doc = "Sample count 8 supported"] + pub const TYPE_8: Self = Self(0b1000); + #[doc = "Sample count 16 supported"] + pub const TYPE_16: Self = Self(0b1_0000); + #[doc = "Sample count 32 supported"] + pub const TYPE_32: Self = Self(0b10_0000); + #[doc = "Sample count 64 supported"] + pub const TYPE_64: Self = Self(0b100_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AttachmentDescriptionFlags(pub(crate) Flags); +vk_bitflags_wrapped!(AttachmentDescriptionFlags, Flags); +impl AttachmentDescriptionFlags { + #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] + pub const MAY_ALIAS: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct StencilFaceFlags(pub(crate) Flags); +vk_bitflags_wrapped!(StencilFaceFlags, Flags); +impl StencilFaceFlags { + #[doc = "Front face"] + pub const FRONT: Self = Self(0b1); + #[doc = "Back face"] + pub const BACK: Self = Self(0b10); + #[doc = "Front and back faces"] + pub const FRONT_AND_BACK: Self = Self(0x0000_0003); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorPoolCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorPoolCreateFlags, Flags); +impl DescriptorPoolCreateFlags { + #[doc = "Descriptor sets may be freed individually"] + pub const FREE_DESCRIPTOR_SET: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DependencyFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DependencyFlags, Flags); +impl DependencyFlags { + #[doc = "Dependency is per pixel region "] + pub const BY_REGION: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SemaphoreWaitFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SemaphoreWaitFlags, Flags); +impl SemaphoreWaitFlags { + pub const ANY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, Flags); +impl DisplayPlaneAlphaFlagsKHR { + pub const OPAQUE: Self = Self(0b1); + pub const GLOBAL: Self = Self(0b10); + pub const PER_PIXEL: Self = Self(0b100); + pub const PER_PIXEL_PREMULTIPLIED: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, Flags); +impl CompositeAlphaFlagsKHR { + pub const OPAQUE: Self = Self(0b1); + pub const PRE_MULTIPLIED: Self = Self(0b10); + pub const POST_MULTIPLIED: Self = Self(0b100); + pub const INHERIT: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, Flags); +impl SurfaceTransformFlagsKHR { + pub const IDENTITY: Self = Self(0b1); + pub const ROTATE_90: Self = Self(0b10); + pub const ROTATE_180: Self = Self(0b100); + pub const ROTATE_270: Self = Self(0b1000); + pub const HORIZONTAL_MIRROR: Self = Self(0b1_0000); + pub const HORIZONTAL_MIRROR_ROTATE_90: Self = Self(0b10_0000); + pub const HORIZONTAL_MIRROR_ROTATE_180: Self = Self(0b100_0000); + pub const HORIZONTAL_MIRROR_ROTATE_270: Self = Self(0b1000_0000); + pub const INHERIT: Self = Self(0b1_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags); +vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, Flags); +impl SwapchainImageUsageFlagsANDROID { + pub const SHARED: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugReportFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugReportFlagsEXT, Flags); +impl DebugReportFlagsEXT { + pub const INFORMATION: Self = Self(0b1); + pub const WARNING: Self = Self(0b10); + pub const PERFORMANCE_WARNING: Self = Self(0b100); + pub const ERROR: Self = Self(0b1000); + pub const DEBUG: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, Flags); +impl ExternalMemoryHandleTypeFlagsNV { + pub const OPAQUE_WIN32: Self = Self(0b1); + pub const OPAQUE_WIN32_KMT: Self = Self(0b10); + pub const D3D11_IMAGE: Self = Self(0b100); + pub const D3D11_IMAGE_KMT: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, Flags); +impl ExternalMemoryFeatureFlagsNV { + pub const DEDICATED_ONLY: Self = Self(0b1); + pub const EXPORTABLE: Self = Self(0b10); + pub const IMPORTABLE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SubgroupFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SubgroupFeatureFlags, Flags); +impl SubgroupFeatureFlags { + #[doc = "Basic subgroup operations"] + pub const BASIC: Self = Self(0b1); + #[doc = "Vote subgroup operations"] + pub const VOTE: Self = Self(0b10); + #[doc = "Arithmetic subgroup operations"] + pub const ARITHMETIC: Self = Self(0b100); + #[doc = "Ballot subgroup operations"] + pub const BALLOT: Self = Self(0b1000); + #[doc = "Shuffle subgroup operations"] + pub const SHUFFLE: Self = Self(0b1_0000); + #[doc = "Shuffle relative subgroup operations"] + pub const SHUFFLE_RELATIVE: Self = Self(0b10_0000); + #[doc = "Clustered subgroup operations"] + pub const CLUSTERED: Self = Self(0b100_0000); + #[doc = "Quad subgroup operations"] + pub const QUAD: Self = Self(0b1000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, Flags); +impl IndirectCommandsLayoutUsageFlagsNV { + pub const EXPLICIT_PREPROCESS: Self = Self(0b1); + pub const INDEXED_SEQUENCES: Self = Self(0b10); + pub const UNORDERED_SEQUENCES: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct IndirectStateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(IndirectStateFlagsNV, Flags); +impl IndirectStateFlagsNV { + pub const FLAG_FRONTFACE: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PrivateDataSlotCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PrivateDataSlotCreateFlags, Flags); +impl PrivateDataSlotCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, Flags); +impl DescriptorSetLayoutCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, Flags); +impl ExternalMemoryHandleTypeFlags { + pub const OPAQUE_FD: Self = Self(0b1); + pub const OPAQUE_WIN32: Self = Self(0b10); + pub const OPAQUE_WIN32_KMT: Self = Self(0b100); + pub const D3D11_TEXTURE: Self = Self(0b1000); + pub const D3D11_TEXTURE_KMT: Self = Self(0b1_0000); + pub const D3D12_HEAP: Self = Self(0b10_0000); + pub const D3D12_RESOURCE: Self = Self(0b100_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, Flags); +impl ExternalMemoryFeatureFlags { + pub const DEDICATED_ONLY: Self = Self(0b1); + pub const EXPORTABLE: Self = Self(0b10); + pub const IMPORTABLE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, Flags); +impl ExternalSemaphoreHandleTypeFlags { + pub const OPAQUE_FD: Self = Self(0b1); + pub const OPAQUE_WIN32: Self = Self(0b10); + pub const OPAQUE_WIN32_KMT: Self = Self(0b100); + pub const D3D12_FENCE: Self = Self(0b1000); + pub const D3D11_FENCE: Self = Self::D3D12_FENCE; + pub const SYNC_FD: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, Flags); +impl ExternalSemaphoreFeatureFlags { + pub const EXPORTABLE: Self = Self(0b1); + pub const IMPORTABLE: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SemaphoreImportFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SemaphoreImportFlags, Flags); +impl SemaphoreImportFlags { + pub const TEMPORARY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, Flags); +impl ExternalFenceHandleTypeFlags { + pub const OPAQUE_FD: Self = Self(0b1); + pub const OPAQUE_WIN32: Self = Self(0b10); + pub const OPAQUE_WIN32_KMT: Self = Self(0b100); + pub const SYNC_FD: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalFenceFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalFenceFeatureFlags, Flags); +impl ExternalFenceFeatureFlags { + pub const EXPORTABLE: Self = Self(0b1); + pub const IMPORTABLE: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FenceImportFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FenceImportFlags, Flags); +impl FenceImportFlags { + pub const TEMPORARY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, Flags); +impl SurfaceCounterFlagsEXT { + pub const VBLANK: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PeerMemoryFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PeerMemoryFeatureFlags, Flags); +impl PeerMemoryFeatureFlags { + #[doc = "Can read with vkCmdCopy commands"] + pub const COPY_SRC: Self = Self(0b1); + #[doc = "Can write with vkCmdCopy commands"] + pub const COPY_DST: Self = Self(0b10); + #[doc = "Can read with any access type/command"] + pub const GENERIC_SRC: Self = Self(0b100); + #[doc = "Can write with and access type/command"] + pub const GENERIC_DST: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryAllocateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryAllocateFlags, Flags); +impl MemoryAllocateFlags { + #[doc = "Force allocation on specific devices"] + pub const DEVICE_MASK: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, Flags); +impl DeviceGroupPresentModeFlagsKHR { + #[doc = "Present from local memory"] + pub const LOCAL: Self = Self(0b1); + #[doc = "Present from remote memory"] + pub const REMOTE: Self = Self(0b10); + #[doc = "Present sum of local and/or remote memory"] + pub const SUM: Self = Self(0b100); + #[doc = "Each physical device presents from local memory"] + pub const LOCAL_MULTI_DEVICE: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, Flags); +impl SwapchainCreateFlagsKHR {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SubpassDescriptionFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SubpassDescriptionFlags, Flags); +impl SubpassDescriptionFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, Flags); +impl DebugUtilsMessageSeverityFlagsEXT { + pub const VERBOSE: Self = Self(0b1); + pub const INFO: Self = Self(0b1_0000); + pub const WARNING: Self = Self(0b1_0000_0000); + pub const ERROR: Self = Self(0b1_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, Flags); +impl DebugUtilsMessageTypeFlagsEXT { + pub const GENERAL: Self = Self(0b1); + pub const VALIDATION: Self = Self(0b10); + pub const PERFORMANCE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorBindingFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorBindingFlags, Flags); +impl DescriptorBindingFlags { + pub const UPDATE_AFTER_BIND: Self = Self(0b1); + pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(0b10); + pub const PARTIALLY_BOUND: Self = Self(0b100); + pub const VARIABLE_DESCRIPTOR_COUNT: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, Flags); +impl ConditionalRenderingFlagsEXT { + pub const INVERTED: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ResolveModeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ResolveModeFlags, Flags); +impl ResolveModeFlags { + pub const NONE: Self = Self(0); + pub const SAMPLE_ZERO: Self = Self(0b1); + pub const AVERAGE: Self = Self(0b10); + pub const MIN: Self = Self(0b100); + pub const MAX: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct GeometryInstanceFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, Flags); +impl GeometryInstanceFlagsKHR { + pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(0b1); + pub const TRIANGLE_FLIP_FACING: Self = Self(0b10); + pub const FORCE_OPAQUE: Self = Self(0b100); + pub const FORCE_NO_OPAQUE: Self = Self(0b1000); + pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = Self::TRIANGLE_FLIP_FACING; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct GeometryFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(GeometryFlagsKHR, Flags); +impl GeometryFlagsKHR { + pub const OPAQUE: Self = Self(0b1); + pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, Flags); +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_UPDATE: Self = Self(0b1); + pub const ALLOW_COMPACTION: Self = Self(0b10); + pub const PREFER_FAST_TRACE: Self = Self(0b100); + pub const PREFER_FAST_BUILD: Self = Self(0b1000); + pub const LOW_MEMORY: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, Flags); +impl AccelerationStructureCreateFlagsKHR { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FramebufferCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FramebufferCreateFlags, Flags); +impl FramebufferCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, Flags); +impl DeviceDiagnosticsConfigFlagsNV { + pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1); + pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10); + pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(0b100); + pub const ENABLE_SHADER_ERROR_REPORTING: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCreationFeedbackFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCreationFeedbackFlags, Flags); +impl PipelineCreationFeedbackFlags { + pub const VALID: Self = Self(0b1); + pub const VALID_EXT: Self = Self::VALID; + pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10); + pub const APPLICATION_PIPELINE_CACHE_HIT_EXT: Self = Self::APPLICATION_PIPELINE_CACHE_HIT; + pub const BASE_PIPELINE_ACCELERATION: Self = Self(0b100); + pub const BASE_PIPELINE_ACCELERATION_EXT: Self = Self::BASE_PIPELINE_ACCELERATION; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryDecompressionMethodFlagsNV(pub(crate) Flags64); +vk_bitflags_wrapped!(MemoryDecompressionMethodFlagsNV, Flags64); +impl MemoryDecompressionMethodFlagsNV { + pub const GDEFLATE_1_0: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, Flags); +impl PerformanceCounterDescriptionFlagsKHR { + pub const PERFORMANCE_IMPACTING: Self = Self(0b1); + pub const CONCURRENTLY_IMPACTED: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, Flags); +impl AcquireProfilingLockFlagsKHR {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags); +vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, Flags); +impl ShaderCorePropertiesFlagsAMD {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ShaderModuleCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ShaderModuleCreateFlags, Flags); +impl ShaderModuleCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, Flags); +impl PipelineCompilerControlFlagsAMD {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ToolPurposeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ToolPurposeFlags, Flags); +impl ToolPurposeFlags { + pub const VALIDATION: Self = Self(0b1); + pub const VALIDATION_EXT: Self = Self::VALIDATION; + pub const PROFILING: Self = Self(0b10); + pub const PROFILING_EXT: Self = Self::PROFILING; + pub const TRACING: Self = Self(0b100); + pub const TRACING_EXT: Self = Self::TRACING; + pub const ADDITIONAL_FEATURES: Self = Self(0b1000); + pub const ADDITIONAL_FEATURES_EXT: Self = Self::ADDITIONAL_FEATURES; + pub const MODIFYING_FEATURES: Self = Self(0b1_0000); + pub const MODIFYING_FEATURES_EXT: Self = Self::MODIFYING_FEATURES; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccessFlags2(pub(crate) Flags64); +vk_bitflags_wrapped!(AccessFlags2, Flags64); +impl AccessFlags2 { + pub const NONE: Self = Self(0); + pub const NONE_KHR: Self = Self::NONE; + pub const INDIRECT_COMMAND_READ: Self = Self(0b1); + pub const INDIRECT_COMMAND_READ_KHR: Self = Self::INDIRECT_COMMAND_READ; + pub const INDEX_READ: Self = Self(0b10); + pub const INDEX_READ_KHR: Self = Self::INDEX_READ; + pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100); + pub const VERTEX_ATTRIBUTE_READ_KHR: Self = Self::VERTEX_ATTRIBUTE_READ; + pub const UNIFORM_READ: Self = Self(0b1000); + pub const UNIFORM_READ_KHR: Self = Self::UNIFORM_READ; + pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000); + pub const INPUT_ATTACHMENT_READ_KHR: Self = Self::INPUT_ATTACHMENT_READ; + pub const SHADER_READ: Self = Self(0b10_0000); + pub const SHADER_READ_KHR: Self = Self::SHADER_READ; + pub const SHADER_WRITE: Self = Self(0b100_0000); + pub const SHADER_WRITE_KHR: Self = Self::SHADER_WRITE; + pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000); + pub const COLOR_ATTACHMENT_READ_KHR: Self = Self::COLOR_ATTACHMENT_READ; + pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000); + pub const COLOR_ATTACHMENT_WRITE_KHR: Self = Self::COLOR_ATTACHMENT_WRITE; + pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_READ_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT_READ; + pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_WRITE_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT_WRITE; + pub const TRANSFER_READ: Self = Self(0b1000_0000_0000); + pub const TRANSFER_READ_KHR: Self = Self::TRANSFER_READ; + pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000); + pub const TRANSFER_WRITE_KHR: Self = Self::TRANSFER_WRITE; + pub const HOST_READ: Self = Self(0b10_0000_0000_0000); + pub const HOST_READ_KHR: Self = Self::HOST_READ; + pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000); + pub const HOST_WRITE_KHR: Self = Self::HOST_WRITE; + pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000); + pub const MEMORY_READ_KHR: Self = Self::MEMORY_READ; + pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000); + pub const MEMORY_WRITE_KHR: Self = Self::MEMORY_WRITE; + pub const SHADER_SAMPLED_READ: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SHADER_SAMPLED_READ_KHR: Self = Self::SHADER_SAMPLED_READ; + pub const SHADER_STORAGE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SHADER_STORAGE_READ_KHR: Self = Self::SHADER_STORAGE_READ; + pub const SHADER_STORAGE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SHADER_STORAGE_WRITE_KHR: Self = Self::SHADER_STORAGE_WRITE; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineStageFlags2(pub(crate) Flags64); +vk_bitflags_wrapped!(PipelineStageFlags2, Flags64); +impl PipelineStageFlags2 { + pub const NONE: Self = Self(0); + pub const NONE_KHR: Self = Self::NONE; + pub const TOP_OF_PIPE: Self = Self(0b1); + pub const TOP_OF_PIPE_KHR: Self = Self::TOP_OF_PIPE; + pub const DRAW_INDIRECT: Self = Self(0b10); + pub const DRAW_INDIRECT_KHR: Self = Self::DRAW_INDIRECT; + pub const VERTEX_INPUT: Self = Self(0b100); + pub const VERTEX_INPUT_KHR: Self = Self::VERTEX_INPUT; + pub const VERTEX_SHADER: Self = Self(0b1000); + pub const VERTEX_SHADER_KHR: Self = Self::VERTEX_SHADER; + pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); + pub const TESSELLATION_CONTROL_SHADER_KHR: Self = Self::TESSELLATION_CONTROL_SHADER; + pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); + pub const TESSELLATION_EVALUATION_SHADER_KHR: Self = Self::TESSELLATION_EVALUATION_SHADER; + pub const GEOMETRY_SHADER: Self = Self(0b100_0000); + pub const GEOMETRY_SHADER_KHR: Self = Self::GEOMETRY_SHADER; + pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); + pub const FRAGMENT_SHADER_KHR: Self = Self::FRAGMENT_SHADER; + pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); + pub const EARLY_FRAGMENT_TESTS_KHR: Self = Self::EARLY_FRAGMENT_TESTS; + pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); + pub const LATE_FRAGMENT_TESTS_KHR: Self = Self::LATE_FRAGMENT_TESTS; + pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); + pub const COLOR_ATTACHMENT_OUTPUT_KHR: Self = Self::COLOR_ATTACHMENT_OUTPUT; + pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); + pub const COMPUTE_SHADER_KHR: Self = Self::COMPUTE_SHADER; + pub const ALL_TRANSFER: Self = Self(0b1_0000_0000_0000); + pub const ALL_TRANSFER_KHR: Self = Self::ALL_TRANSFER; + pub const TRANSFER: Self = Self::ALL_TRANSFER_KHR; + pub const TRANSFER_KHR: Self = Self::ALL_TRANSFER; + pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); + pub const BOTTOM_OF_PIPE_KHR: Self = Self::BOTTOM_OF_PIPE; + pub const HOST: Self = Self(0b100_0000_0000_0000); + pub const HOST_KHR: Self = Self::HOST; + pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); + pub const ALL_GRAPHICS_KHR: Self = Self::ALL_GRAPHICS; + pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); + pub const ALL_COMMANDS_KHR: Self = Self::ALL_COMMANDS; + pub const COPY: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); + pub const COPY_KHR: Self = Self::COPY; + pub const RESOLVE: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESOLVE_KHR: Self = Self::RESOLVE; + pub const BLIT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); + pub const BLIT_KHR: Self = Self::BLIT; + pub const CLEAR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const CLEAR_KHR: Self = Self::CLEAR; + pub const INDEX_INPUT: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const INDEX_INPUT_KHR: Self = Self::INDEX_INPUT; + pub const VERTEX_ATTRIBUTE_INPUT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const VERTEX_ATTRIBUTE_INPUT_KHR: Self = Self::VERTEX_ATTRIBUTE_INPUT; + pub const PRE_RASTERIZATION_SHADERS: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const PRE_RASTERIZATION_SHADERS_KHR: Self = Self::PRE_RASTERIZATION_SHADERS; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SubmitFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SubmitFlags, Flags); +impl SubmitFlags { + pub const PROTECTED: Self = Self(0b1); + pub const PROTECTED_KHR: Self = Self::PROTECTED; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct EventCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(EventCreateFlags, Flags); +impl EventCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineLayoutCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineLayoutCreateFlags, Flags); +impl PipelineLayoutCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, Flags); +impl PipelineColorBlendStateCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, Flags); +impl PipelineDepthStencilStateCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct GraphicsPipelineLibraryFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(GraphicsPipelineLibraryFlagsEXT, Flags); +impl GraphicsPipelineLibraryFlagsEXT { + pub const VERTEX_INPUT_INTERFACE: Self = Self(0b1); + pub const PRE_RASTERIZATION_SHADERS: Self = Self(0b10); + pub const FRAGMENT_SHADER: Self = Self(0b100); + pub const FRAGMENT_OUTPUT_INTERFACE: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceAddressBindingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceAddressBindingFlagsEXT, Flags); +impl DeviceAddressBindingFlagsEXT { + pub const INTERNAL_OBJECT: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PresentScalingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PresentScalingFlagsEXT, Flags); +impl PresentScalingFlagsEXT { + pub const ONE_TO_ONE: Self = Self(0b1); + pub const ASPECT_RATIO_STRETCH: Self = Self(0b10); + pub const STRETCH: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PresentGravityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PresentGravityFlagsEXT, Flags); +impl PresentGravityFlagsEXT { + pub const MIN: Self = Self(0b1); + pub const MAX: Self = Self(0b10); + pub const CENTERED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags); +impl VideoCodecOperationFlagsKHR { + pub const NONE: Self = Self(0); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoChromaSubsamplingFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, Flags); +impl VideoChromaSubsamplingFlagsKHR { + pub const INVALID: Self = Self(0); + pub const MONOCHROME: Self = Self(0b1); + pub const TYPE_420: Self = Self(0b10); + pub const TYPE_422: Self = Self(0b100); + pub const TYPE_444: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoComponentBitDepthFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, Flags); +impl VideoComponentBitDepthFlagsKHR { + pub const INVALID: Self = Self(0); + pub const TYPE_8: Self = Self(0b1); + pub const TYPE_10: Self = Self(0b100); + pub const TYPE_12: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoCapabilityFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, Flags); +impl VideoCapabilityFlagsKHR { + pub const PROTECTED_CONTENT: Self = Self(0b1); + pub const SEPARATE_REFERENCE_IMAGES: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, Flags); +impl VideoSessionCreateFlagsKHR { + pub const PROTECTED_CONTENT: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeH264PictureLayoutFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsKHR, Flags); +impl VideoDecodeH264PictureLayoutFlagsKHR { + pub const PROGRESSIVE: Self = Self(0); + pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1); + pub const INTERLACED_SEPARATE_PLANES: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoCodingControlFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, Flags); +impl VideoCodingControlFlagsKHR { + pub const RESET: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeUsageFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeUsageFlagsKHR, Flags); +impl VideoDecodeUsageFlagsKHR { + pub const DEFAULT: Self = Self(0); + pub const TRANSCODING: Self = Self(0b1); + pub const OFFLINE: Self = Self(0b10); + pub const STREAMING: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeCapabilityFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeCapabilityFlagsKHR, Flags); +impl VideoDecodeCapabilityFlagsKHR { + pub const DPB_AND_OUTPUT_COINCIDE: Self = Self(0b1); + pub const DPB_AND_OUTPUT_DISTINCT: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeUsageFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeUsageFlagsKHR, Flags); +impl VideoEncodeUsageFlagsKHR { + pub const DEFAULT: Self = Self(0); + pub const TRANSCODING: Self = Self(0b1); + pub const STREAMING: Self = Self(0b10); + pub const RECORDING: Self = Self(0b100); + pub const CONFERENCING: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeContentFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeContentFlagsKHR, Flags); +impl VideoEncodeContentFlagsKHR { + pub const DEFAULT: Self = Self(0); + pub const CAMERA: Self = Self(0b1); + pub const DESKTOP: Self = Self(0b10); + pub const RENDERED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeCapabilityFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeCapabilityFlagsKHR, Flags); +impl VideoEncodeCapabilityFlagsKHR { + pub const PRECEDING_EXTERNALLY_ENCODED_BYTES: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, Flags); +impl VideoEncodeRateControlModeFlagsKHR { + pub const NONE: Self = Self(0); + pub const CBR: Self = Self(1); + pub const VBR: Self = Self(2); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags); +impl VideoEncodeH264CapabilityFlagsEXT { + pub const DIRECT_8X8_INFERENCE_ENABLED: Self = Self(0b1); + pub const DIRECT_8X8_INFERENCE_DISABLED: Self = Self(0b10); + pub const SEPARATE_COLOUR_PLANE: Self = Self(0b100); + pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b1000); + pub const SCALING_LISTS: Self = Self(0b1_0000); + pub const HRD_COMPLIANCE: Self = Self(0b10_0000); + pub const CHROMA_QP_OFFSET: Self = Self(0b100_0000); + pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b1000_0000); + pub const PIC_INIT_QP_MINUS26: Self = Self(0b1_0000_0000); + pub const WEIGHTED_PRED: Self = Self(0b10_0000_0000); + pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b100_0000_0000); + pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b1000_0000_0000); + pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1_0000_0000_0000); + pub const TRANSFORM_8X8: Self = Self(0b10_0000_0000_0000); + pub const CABAC: Self = Self(0b100_0000_0000_0000); + pub const CAVLC: Self = Self(0b1000_0000_0000_0000); + pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b10_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b100_0000_0000_0000_0000); + pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b1000_0000_0000_0000_0000); + pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const SLICE_MB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH264InputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH264InputModeFlagsEXT, Flags); +impl VideoEncodeH264InputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH264OutputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH264OutputModeFlagsEXT, Flags); +impl VideoEncodeH264OutputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags); +vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags); +impl ImageFormatConstraintsFlagsFUCHSIA {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageConstraintsInfoFlagsFUCHSIA(pub(crate) Flags); +vk_bitflags_wrapped!(ImageConstraintsInfoFlagsFUCHSIA, Flags); +impl ImageConstraintsInfoFlagsFUCHSIA { + pub const CPU_READ_RARELY: Self = Self(0b1); + pub const CPU_READ_OFTEN: Self = Self(0b10); + pub const CPU_WRITE_RARELY: Self = Self(0b100); + pub const CPU_WRITE_OFTEN: Self = Self(0b1000); + pub const PROTECTED_OPTIONAL: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FormatFeatureFlags2(pub(crate) Flags64); +vk_bitflags_wrapped!(FormatFeatureFlags2, Flags64); +impl FormatFeatureFlags2 { + pub const SAMPLED_IMAGE: Self = Self(0b1); + pub const SAMPLED_IMAGE_KHR: Self = Self::SAMPLED_IMAGE; + pub const STORAGE_IMAGE: Self = Self(0b10); + pub const STORAGE_IMAGE_KHR: Self = Self::STORAGE_IMAGE; + pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); + pub const STORAGE_IMAGE_ATOMIC_KHR: Self = Self::STORAGE_IMAGE_ATOMIC; + pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); + pub const UNIFORM_TEXEL_BUFFER_KHR: Self = Self::UNIFORM_TEXEL_BUFFER; + pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); + pub const STORAGE_TEXEL_BUFFER_KHR: Self = Self::STORAGE_TEXEL_BUFFER; + pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); + pub const STORAGE_TEXEL_BUFFER_ATOMIC_KHR: Self = Self::STORAGE_TEXEL_BUFFER_ATOMIC; + pub const VERTEX_BUFFER: Self = Self(0b100_0000); + pub const VERTEX_BUFFER_KHR: Self = Self::VERTEX_BUFFER; + pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); + pub const COLOR_ATTACHMENT_KHR: Self = Self::COLOR_ATTACHMENT; + pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); + pub const COLOR_ATTACHMENT_BLEND_KHR: Self = Self::COLOR_ATTACHMENT_BLEND; + pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT; + pub const BLIT_SRC: Self = Self(0b100_0000_0000); + pub const BLIT_SRC_KHR: Self = Self::BLIT_SRC; + pub const BLIT_DST: Self = Self(0b1000_0000_0000); + pub const BLIT_DST_KHR: Self = Self::BLIT_DST; + pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_LINEAR_KHR: Self = Self::SAMPLED_IMAGE_FILTER_LINEAR; + pub const SAMPLED_IMAGE_FILTER_CUBIC: Self = Self(0b10_0000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC; + pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000); + pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC; + pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000); + pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST; + pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_MINMAX_KHR: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX; + pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000); + pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = + Self(0b1000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = + Self(0b1_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = + Self(0b10_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE; + pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const DISJOINT_KHR: Self = Self::DISJOINT; + pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES; + pub const STORAGE_READ_WITHOUT_FORMAT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000); + pub const STORAGE_READ_WITHOUT_FORMAT_KHR: Self = Self::STORAGE_READ_WITHOUT_FORMAT; + pub const STORAGE_WRITE_WITHOUT_FORMAT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); + pub const STORAGE_WRITE_WITHOUT_FORMAT_KHR: Self = Self::STORAGE_WRITE_WITHOUT_FORMAT; + pub const SAMPLED_IMAGE_DEPTH_COMPARISON: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_DEPTH_COMPARISON_KHR: Self = Self::SAMPLED_IMAGE_DEPTH_COMPARISON; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct RenderingFlags(pub(crate) Flags); +vk_bitflags_wrapped!(RenderingFlags, Flags); +impl RenderingFlags { + pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(0b1); + pub const CONTENTS_SECONDARY_COMMAND_BUFFERS_KHR: Self = + Self::CONTENTS_SECONDARY_COMMAND_BUFFERS; + pub const SUSPENDING: Self = Self(0b10); + pub const SUSPENDING_KHR: Self = Self::SUSPENDING; + pub const RESUMING: Self = Self(0b100); + pub const RESUMING_KHR: Self = Self::RESUMING; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, Flags); +impl VideoEncodeH265CapabilityFlagsEXT { + pub const SEPARATE_COLOUR_PLANE: Self = Self(0b1); + pub const SCALING_LISTS: Self = Self(0b10); + pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED: Self = Self(0b100); + pub const PCM_ENABLE: Self = Self(0b1000); + pub const SPS_TEMPORAL_MVP_ENABLED: Self = Self(0b1_0000); + pub const HRD_COMPLIANCE: Self = Self(0b10_0000); + pub const INIT_QP_MINUS26: Self = Self(0b100_0000); + pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1000_0000); + pub const SIGN_DATA_HIDING_ENABLED: Self = Self(0b1_0000_0000); + pub const TRANSFORM_SKIP_ENABLED: Self = Self(0b10_0000_0000); + pub const TRANSFORM_SKIP_DISABLED: Self = Self(0b100_0000_0000); + pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT: Self = Self(0b1000_0000_0000); + pub const WEIGHTED_PRED: Self = Self(0b1_0000_0000_0000); + pub const WEIGHTED_BIPRED: Self = Self(0b10_0000_0000_0000); + pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b100_0000_0000_0000); + pub const TRANSQUANT_BYPASS_ENABLED: Self = Self(0b1000_0000_0000_0000); + pub const ENTROPY_CODING_SYNC_ENABLED: Self = Self(0b1_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED: Self = Self(0b10_0000_0000_0000_0000); + pub const MULTIPLE_TILE_PER_FRAME: Self = Self(0b100_0000_0000_0000_0000); + pub const MULTIPLE_SLICE_PER_TILE: Self = Self(0b1000_0000_0000_0000_0000); + pub const MULTIPLE_TILE_PER_SLICE: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const SLICE_SEGMENT_CTB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const DEPENDENT_SLICE_SEGMENT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265InputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265InputModeFlagsEXT, Flags); +impl VideoEncodeH265InputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE_SEGMENT: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265OutputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265OutputModeFlagsEXT, Flags); +impl VideoEncodeH265OutputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE_SEGMENT: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, Flags); +impl VideoEncodeH265CtbSizeFlagsEXT { + pub const TYPE_16: Self = Self(0b1); + pub const TYPE_32: Self = Self(0b10); + pub const TYPE_64: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265TransformBlockSizeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265TransformBlockSizeFlagsEXT, Flags); +impl VideoEncodeH265TransformBlockSizeFlagsEXT { + pub const TYPE_4: Self = Self(0b1); + pub const TYPE_8: Self = Self(0b10); + pub const TYPE_16: Self = Self(0b100); + pub const TYPE_32: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExportMetalObjectTypeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ExportMetalObjectTypeFlagsEXT, Flags); +impl ExportMetalObjectTypeFlagsEXT { + pub const METAL_DEVICE: Self = Self(0b1); + pub const METAL_COMMAND_QUEUE: Self = Self(0b10); + pub const METAL_BUFFER: Self = Self(0b100); + pub const METAL_TEXTURE: Self = Self(0b1000); + pub const METAL_IOSURFACE: Self = Self(0b1_0000); + pub const METAL_SHARED_EVENT: Self = Self(0b10_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct InstanceCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(InstanceCreateFlags, Flags); +impl InstanceCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageCompressionFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCompressionFlagsEXT, Flags); +impl ImageCompressionFlagsEXT { + pub const DEFAULT: Self = Self(0); + pub const FIXED_RATE_DEFAULT: Self = Self(0b1); + pub const FIXED_RATE_EXPLICIT: Self = Self(0b10); + pub const DISABLED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageCompressionFixedRateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCompressionFixedRateFlagsEXT, Flags); +impl ImageCompressionFixedRateFlagsEXT { + pub const NONE: Self = Self(0); + pub const TYPE_1BPC: Self = Self(0b1); + pub const TYPE_2BPC: Self = Self(0b10); + pub const TYPE_3BPC: Self = Self(0b100); + pub const TYPE_4BPC: Self = Self(0b1000); + pub const TYPE_5BPC: Self = Self(0b1_0000); + pub const TYPE_6BPC: Self = Self(0b10_0000); + pub const TYPE_7BPC: Self = Self(0b100_0000); + pub const TYPE_8BPC: Self = Self(0b1000_0000); + pub const TYPE_9BPC: Self = Self(0b1_0000_0000); + pub const TYPE_10BPC: Self = Self(0b10_0000_0000); + pub const TYPE_11BPC: Self = Self(0b100_0000_0000); + pub const TYPE_12BPC: Self = Self(0b1000_0000_0000); + pub const TYPE_13BPC: Self = Self(0b1_0000_0000_0000); + pub const TYPE_14BPC: Self = Self(0b10_0000_0000_0000); + pub const TYPE_15BPC: Self = Self(0b100_0000_0000_0000); + pub const TYPE_16BPC: Self = Self(0b1000_0000_0000_0000); + pub const TYPE_17BPC: Self = Self(0b1_0000_0000_0000_0000); + pub const TYPE_18BPC: Self = Self(0b10_0000_0000_0000_0000); + pub const TYPE_19BPC: Self = Self(0b100_0000_0000_0000_0000); + pub const TYPE_20BPC: Self = Self(0b1000_0000_0000_0000_0000); + pub const TYPE_21BPC: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const TYPE_22BPC: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const TYPE_23BPC: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const TYPE_24BPC: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowGridSizeFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowGridSizeFlagsNV, Flags); +impl OpticalFlowGridSizeFlagsNV { + pub const UNKNOWN: Self = Self(0); + pub const TYPE_1X1: Self = Self(0b1); + pub const TYPE_2X2: Self = Self(0b10); + pub const TYPE_4X4: Self = Self(0b100); + pub const TYPE_8X8: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowUsageFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowUsageFlagsNV, Flags); +impl OpticalFlowUsageFlagsNV { + pub const UNKNOWN: Self = Self(0); + pub const INPUT: Self = Self(0b1); + pub const OUTPUT: Self = Self(0b10); + pub const HINT: Self = Self(0b100); + pub const COST: Self = Self(0b1000); + pub const GLOBAL_FLOW: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowSessionCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowSessionCreateFlagsNV, Flags); +impl OpticalFlowSessionCreateFlagsNV { + pub const ENABLE_HINT: Self = Self(0b1); + pub const ENABLE_COST: Self = Self(0b10); + pub const ENABLE_GLOBAL_FLOW: Self = Self(0b100); + pub const ALLOW_REGIONS: Self = Self(0b1000); + pub const BOTH_DIRECTIONS: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowExecuteFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowExecuteFlagsNV, Flags); +impl OpticalFlowExecuteFlagsNV { + pub const DISABLE_TEMPORAL_HINTS: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BuildMicromapFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(BuildMicromapFlagsEXT, Flags); +impl BuildMicromapFlagsEXT { + pub const PREFER_FAST_TRACE: Self = Self(0b1); + pub const PREFER_FAST_BUILD: Self = Self(0b10); + pub const ALLOW_COMPACTION: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MicromapCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(MicromapCreateFlagsEXT, Flags); +impl MicromapCreateFlagsEXT { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); +} diff --git a/third_party/rust/ash/src/vk/const_debugs.rs b/third_party/rust/ash/src/vk/const_debugs.rs new file mode 100644 index 0000000000..6508306e30 --- /dev/null +++ b/third_party/rust/ash/src/vk/const_debugs.rs @@ -0,0 +1,7167 @@ +use crate::prelude::debug_flags; +use crate::vk::bitflags::*; +use crate::vk::definitions::*; +use crate::vk::enums::*; +use std::fmt; +impl fmt::Debug for AccelerationStructureBuildTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::HOST => Some("HOST"), + Self::DEVICE => Some("DEVICE"), + Self::HOST_OR_DEVICE => Some("HOST_OR_DEVICE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureCompatibilityKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMPATIBLE => Some("COMPATIBLE"), + Self::INCOMPATIBLE => Some("INCOMPATIBLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccelerationStructureCreateFlagsKHR::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + ), + ( + AccelerationStructureCreateFlagsKHR::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + ( + AccelerationStructureCreateFlagsKHR::MOTION_NV.0, + "MOTION_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccelerationStructureMemoryRequirementsTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OBJECT => Some("OBJECT"), + Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), + Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureMotionInfoFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccelerationStructureMotionInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccelerationStructureMotionInstanceTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATIC => Some("STATIC"), + Self::MATRIX_MOTION => Some("MATRIX_MOTION"), + Self::SRT_MOTION => Some("SRT_MOTION"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + Self::GENERIC => Some("GENERIC"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_WRITE_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", + ), + ( + AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, + "CONDITIONAL_RENDERING_READ_EXT", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_READ_KHR.0, + "ACCELERATION_STRUCTURE_READ_KHR", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR.0, + "ACCELERATION_STRUCTURE_WRITE_KHR", + ), + ( + AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, + "FRAGMENT_DENSITY_MAP_READ_EXT", + ), + ( + AccessFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR", + ), + ( + AccessFlags::COMMAND_PREPROCESS_READ_NV.0, + "COMMAND_PREPROCESS_READ_NV", + ), + ( + AccessFlags::COMMAND_PREPROCESS_WRITE_NV.0, + "COMMAND_PREPROCESS_WRITE_NV", + ), + (AccessFlags::NONE.0, "NONE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccessFlags2 { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[ + (AccessFlags2::NONE.0, "NONE"), + ( + AccessFlags2::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags2::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags2::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags2::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags2::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags2::SHADER_READ.0, "SHADER_READ"), + (AccessFlags2::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags2::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags2::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags2::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags2::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags2::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags2::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags2::HOST_READ.0, "HOST_READ"), + (AccessFlags2::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags2::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags2::MEMORY_WRITE.0, "MEMORY_WRITE"), + (AccessFlags2::SHADER_SAMPLED_READ.0, "SHADER_SAMPLED_READ"), + (AccessFlags2::SHADER_STORAGE_READ.0, "SHADER_STORAGE_READ"), + (AccessFlags2::SHADER_STORAGE_WRITE.0, "SHADER_STORAGE_WRITE"), + ( + AccessFlags2::VIDEO_DECODE_READ_KHR.0, + "VIDEO_DECODE_READ_KHR", + ), + ( + AccessFlags2::VIDEO_DECODE_WRITE_KHR.0, + "VIDEO_DECODE_WRITE_KHR", + ), + (AccessFlags2::RESERVED_46_EXT.0, "RESERVED_46_EXT"), + ( + AccessFlags2::VIDEO_ENCODE_READ_KHR.0, + "VIDEO_ENCODE_READ_KHR", + ), + ( + AccessFlags2::VIDEO_ENCODE_WRITE_KHR.0, + "VIDEO_ENCODE_WRITE_KHR", + ), + ( + AccessFlags2::TRANSFORM_FEEDBACK_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_WRITE_EXT", + ), + ( + AccessFlags2::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", + ), + ( + AccessFlags2::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", + ), + ( + AccessFlags2::CONDITIONAL_RENDERING_READ_EXT.0, + "CONDITIONAL_RENDERING_READ_EXT", + ), + ( + AccessFlags2::COMMAND_PREPROCESS_READ_NV.0, + "COMMAND_PREPROCESS_READ_NV", + ), + ( + AccessFlags2::COMMAND_PREPROCESS_WRITE_NV.0, + "COMMAND_PREPROCESS_WRITE_NV", + ), + ( + AccessFlags2::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR", + ), + ( + AccessFlags2::ACCELERATION_STRUCTURE_READ_KHR.0, + "ACCELERATION_STRUCTURE_READ_KHR", + ), + ( + AccessFlags2::ACCELERATION_STRUCTURE_WRITE_KHR.0, + "ACCELERATION_STRUCTURE_WRITE_KHR", + ), + ( + AccessFlags2::FRAGMENT_DENSITY_MAP_READ_EXT.0, + "FRAGMENT_DENSITY_MAP_READ_EXT", + ), + ( + AccessFlags2::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ( + AccessFlags2::DESCRIPTOR_BUFFER_READ_EXT.0, + "DESCRIPTOR_BUFFER_READ_EXT", + ), + ( + AccessFlags2::INVOCATION_MASK_READ_HUAWEI.0, + "INVOCATION_MASK_READ_HUAWEI", + ), + ( + AccessFlags2::SHADER_BINDING_TABLE_READ_KHR.0, + "SHADER_BINDING_TABLE_READ_KHR", + ), + (AccessFlags2::MICROMAP_READ_EXT.0, "MICROMAP_READ_EXT"), + (AccessFlags2::MICROMAP_WRITE_EXT.0, "MICROMAP_WRITE_EXT"), + (AccessFlags2::OPTICAL_FLOW_READ_NV.0, "OPTICAL_FLOW_READ_NV"), + ( + AccessFlags2::OPTICAL_FLOW_WRITE_NV.0, + "OPTICAL_FLOW_WRITE_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AcquireProfilingLockFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AndroidSurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + Self::NONE_EXT => Some("NONE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + Self::NONE => Some("NONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::FLOAT_CUSTOM_EXT => Some("FLOAT_CUSTOM_EXT"), + Self::INT_CUSTOM_EXT => Some("INT_CUSTOM_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + ( + BufferCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ( + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ( + BufferUsageFlags::VIDEO_DECODE_SRC_KHR.0, + "VIDEO_DECODE_SRC_KHR", + ), + ( + BufferUsageFlags::VIDEO_DECODE_DST_KHR.0, + "VIDEO_DECODE_DST_KHR", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RESERVED_25_AMD.0, "RESERVED_25_AMD"), + ( + BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0, + "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR", + ), + ( + BufferUsageFlags::ACCELERATION_STRUCTURE_STORAGE_KHR.0, + "ACCELERATION_STRUCTURE_STORAGE_KHR", + ), + ( + BufferUsageFlags::SHADER_BINDING_TABLE_KHR.0, + "SHADER_BINDING_TABLE_KHR", + ), + (BufferUsageFlags::RESERVED_18_QCOM.0, "RESERVED_18_QCOM"), + ( + BufferUsageFlags::VIDEO_ENCODE_DST_KHR.0, + "VIDEO_ENCODE_DST_KHR", + ), + ( + BufferUsageFlags::VIDEO_ENCODE_SRC_KHR.0, + "VIDEO_ENCODE_SRC_KHR", + ), + ( + BufferUsageFlags::SAMPLER_DESCRIPTOR_BUFFER_EXT.0, + "SAMPLER_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::RESOURCE_DESCRIPTOR_BUFFER_EXT.0, + "RESOURCE_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT.0, + "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0, + "MICROMAP_BUILD_INPUT_READ_ONLY_EXT", + ), + ( + BufferUsageFlags::MICROMAP_STORAGE_EXT.0, + "MICROMAP_STORAGE_EXT", + ), + ( + BufferUsageFlags::SHADER_DEVICE_ADDRESS.0, + "SHADER_DEVICE_ADDRESS", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BufferViewCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BuildAccelerationStructureFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildAccelerationStructureFlagsKHR::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsKHR::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsKHR::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsKHR::LOW_MEMORY.0, + "LOW_MEMORY", + ), + (BuildAccelerationStructureFlagsKHR::MOTION_NV.0, "MOTION_NV"), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_UPDATE_EXT.0, + "ALLOW_OPACITY_MICROMAP_UPDATE_EXT", + ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_DISABLE_OPACITY_MICROMAPS_EXT.0, + "ALLOW_DISABLE_OPACITY_MICROMAPS_EXT", + ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT.0, + "ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT", + ), + ( + BuildAccelerationStructureFlagsKHR::RESERVED_9_NV.0, + "RESERVED_9_NV", + ), + ( + BuildAccelerationStructureFlagsKHR::RESERVED_10_NV.0, + "RESERVED_10_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BuildAccelerationStructureModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BUILD => Some("BUILD"), + Self::UPDATE => Some("UPDATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BuildMicromapFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildMicromapFlagsEXT::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildMicromapFlagsEXT::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildMicromapFlagsEXT::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BuildMicromapModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BUILD => Some("BUILD"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CoarseSampleOrderTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DISPLAY_P3_LINEAR_EXT => Some("DISPLAY_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + Self::DISPLAY_NATIVE_AMD => Some("DISPLAY_NATIVE_AMD"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + ), + ( + CommandPoolResetFlags::RESERVED_1_COREAVI.0, + "RESERVED_1_COREAVI", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CommandPoolTrimFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ComponentTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT16 => Some("FLOAT16"), + Self::FLOAT32 => Some("FLOAT32"), + Self::FLOAT64 => Some("FLOAT64"), + Self::SINT8 => Some("SINT8"), + Self::SINT16 => Some("SINT16"), + Self::SINT32 => Some("SINT32"), + Self::SINT64 => Some("SINT64"), + Self::UINT8 => Some("UINT8"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::UINT64 => Some("UINT64"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CopyAccelerationStructureModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), + Self::SERIALIZE => Some("SERIALIZE"), + Self::DESERIALIZE => Some("DESERIALIZE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CopyMicromapModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::SERIALIZE => Some("SERIALIZE"), + Self::DESERIALIZE => Some("DESERIALIZE"), + Self::COMPACT => Some("COMPACT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CoverageReductionModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::MERGE => Some("MERGE"), + Self::TRUNCATE => Some("TRUNCATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"), + Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"), + Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ( + DebugUtilsMessageTypeFlagsEXT::DEVICE_ADDRESS_BINDING.0, + "DEVICE_ADDRESS_BINDING", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugUtilsMessengerCallbackDataFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugUtilsMessengerCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::FEEDBACK_LOOP_EXT.0, "FEEDBACK_LOOP_EXT"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorBindingFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlags::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlags::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + (DescriptorBindingFlags::PARTIALLY_BOUND.0, "PARTIALLY_BOUND"), + ( + DescriptorBindingFlags::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + (DescriptorBindingFlags::RESERVED_4_QCOM.0, "RESERVED_4_QCOM"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + (DescriptorPoolCreateFlags::HOST_ONLY_EXT.0, "HOST_ONLY_EXT"), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", + ), + ( + DescriptorSetLayoutCreateFlags::EMBEDDED_IMMUTABLE_SAMPLERS_EXT.0, + "EMBEDDED_IMMUTABLE_SAMPLERS_EXT", + ), + ( + DescriptorSetLayoutCreateFlags::RESERVED_3_AMD.0, + "RESERVED_3_AMD", + ), + ( + DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_EXT.0, + "HOST_ONLY_POOL_EXT", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL.0, + "UPDATE_AFTER_BIND_POOL", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::SAMPLE_WEIGHT_IMAGE_QCOM => Some("SAMPLE_WEIGHT_IMAGE_QCOM"), + Self::BLOCK_MATCH_IMAGE_QCOM => Some("BLOCK_MATCH_IMAGE_QCOM"), + Self::MUTABLE_EXT => Some("MUTABLE_EXT"), + Self::INLINE_UNIFORM_BLOCK => Some("INLINE_UNIFORM_BLOCK"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DescriptorUpdateTemplateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PUSH_DESCRIPTORS_KHR => Some("PUSH_DESCRIPTORS_KHR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceAddressBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + DeviceAddressBindingFlagsEXT::INTERNAL_OBJECT.0, + "INTERNAL_OBJECT", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceAddressBindingTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BIND => Some("BIND"), + Self::UNBIND => Some("UNBIND"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceDiagnosticsConfigFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_DEBUG_INFO.0, + "ENABLE_SHADER_DEBUG_INFO", + ), + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_RESOURCE_TRACKING.0, + "ENABLE_RESOURCE_TRACKING", + ), + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_AUTOMATIC_CHECKPOINTS.0, + "ENABLE_AUTOMATIC_CHECKPOINTS", + ), + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_ERROR_REPORTING.0, + "ENABLE_SHADER_ERROR_REPORTING", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceFaultAddressTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::READ_INVALID => Some("READ_INVALID"), + Self::WRITE_INVALID => Some("WRITE_INVALID"), + Self::EXECUTE_INVALID => Some("EXECUTE_INVALID"), + Self::INSTRUCTION_POINTER_UNKNOWN => Some("INSTRUCTION_POINTER_UNKNOWN"), + Self::INSTRUCTION_POINTER_INVALID => Some("INSTRUCTION_POINTER_INVALID"), + Self::INSTRUCTION_POINTER_FAULT => Some("INSTRUCTION_POINTER_FAULT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceFaultVendorBinaryHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceMemoryReportEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALLOCATE => Some("ALLOCATE"), + Self::FREE => Some("FREE"), + Self::IMPORT => Some("IMPORT"), + Self::UNIMPORT => Some("UNIMPORT"), + Self::ALLOCATION_FAILED => Some("ALLOCATION_FAILED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceMemoryReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceQueueCreateFlags::RESERVED_1_QCOM.0, "RESERVED_1_QCOM"), + (DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DirectDriverLoadingFlagsLUNARG { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DirectDriverLoadingModeLUNARG { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::INCLUSIVE => Some("INCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DirectFBSurfaceCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DisplayModeCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DisplaySurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DriverId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::GOOGLE_SWIFTSHADER => Some("GOOGLE_SWIFTSHADER"), + Self::GGP_PROPRIETARY => Some("GGP_PROPRIETARY"), + Self::BROADCOM_PROPRIETARY => Some("BROADCOM_PROPRIETARY"), + Self::MESA_LLVMPIPE => Some("MESA_LLVMPIPE"), + Self::MOLTENVK => Some("MOLTENVK"), + Self::COREAVI_PROPRIETARY => Some("COREAVI_PROPRIETARY"), + Self::JUICE_PROPRIETARY => Some("JUICE_PROPRIETARY"), + Self::VERISILICON_PROPRIETARY => Some("VERISILICON_PROPRIETARY"), + Self::MESA_TURNIP => Some("MESA_TURNIP"), + Self::MESA_V3DV => Some("MESA_V3DV"), + Self::MESA_PANVK => Some("MESA_PANVK"), + Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"), + Self::MESA_VENUS => Some("MESA_VENUS"), + Self::MESA_DOZEN => Some("MESA_DOZEN"), + Self::MESA_NVK => Some("MESA_NVK"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::RAY_TRACING_PIPELINE_STACK_SIZE_KHR => { + Some("RAY_TRACING_PIPELINE_STACK_SIZE_KHR") + } + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), + Self::FRAGMENT_SHADING_RATE_KHR => Some("FRAGMENT_SHADING_RATE_KHR"), + Self::LINE_STIPPLE_EXT => Some("LINE_STIPPLE_EXT"), + Self::VERTEX_INPUT_EXT => Some("VERTEX_INPUT_EXT"), + Self::PATCH_CONTROL_POINTS_EXT => Some("PATCH_CONTROL_POINTS_EXT"), + Self::LOGIC_OP_EXT => Some("LOGIC_OP_EXT"), + Self::COLOR_WRITE_ENABLE_EXT => Some("COLOR_WRITE_ENABLE_EXT"), + Self::TESSELLATION_DOMAIN_ORIGIN_EXT => Some("TESSELLATION_DOMAIN_ORIGIN_EXT"), + Self::DEPTH_CLAMP_ENABLE_EXT => Some("DEPTH_CLAMP_ENABLE_EXT"), + Self::POLYGON_MODE_EXT => Some("POLYGON_MODE_EXT"), + Self::RASTERIZATION_SAMPLES_EXT => Some("RASTERIZATION_SAMPLES_EXT"), + Self::SAMPLE_MASK_EXT => Some("SAMPLE_MASK_EXT"), + Self::ALPHA_TO_COVERAGE_ENABLE_EXT => Some("ALPHA_TO_COVERAGE_ENABLE_EXT"), + Self::ALPHA_TO_ONE_ENABLE_EXT => Some("ALPHA_TO_ONE_ENABLE_EXT"), + Self::LOGIC_OP_ENABLE_EXT => Some("LOGIC_OP_ENABLE_EXT"), + Self::COLOR_BLEND_ENABLE_EXT => Some("COLOR_BLEND_ENABLE_EXT"), + Self::COLOR_BLEND_EQUATION_EXT => Some("COLOR_BLEND_EQUATION_EXT"), + Self::COLOR_WRITE_MASK_EXT => Some("COLOR_WRITE_MASK_EXT"), + Self::RASTERIZATION_STREAM_EXT => Some("RASTERIZATION_STREAM_EXT"), + Self::CONSERVATIVE_RASTERIZATION_MODE_EXT => { + Some("CONSERVATIVE_RASTERIZATION_MODE_EXT") + } + Self::EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT => { + Some("EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT") + } + Self::DEPTH_CLIP_ENABLE_EXT => Some("DEPTH_CLIP_ENABLE_EXT"), + Self::SAMPLE_LOCATIONS_ENABLE_EXT => Some("SAMPLE_LOCATIONS_ENABLE_EXT"), + Self::COLOR_BLEND_ADVANCED_EXT => Some("COLOR_BLEND_ADVANCED_EXT"), + Self::PROVOKING_VERTEX_MODE_EXT => Some("PROVOKING_VERTEX_MODE_EXT"), + Self::LINE_RASTERIZATION_MODE_EXT => Some("LINE_RASTERIZATION_MODE_EXT"), + Self::LINE_STIPPLE_ENABLE_EXT => Some("LINE_STIPPLE_ENABLE_EXT"), + Self::DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT => Some("DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT"), + Self::VIEWPORT_W_SCALING_ENABLE_NV => Some("VIEWPORT_W_SCALING_ENABLE_NV"), + Self::VIEWPORT_SWIZZLE_NV => Some("VIEWPORT_SWIZZLE_NV"), + Self::COVERAGE_TO_COLOR_ENABLE_NV => Some("COVERAGE_TO_COLOR_ENABLE_NV"), + Self::COVERAGE_TO_COLOR_LOCATION_NV => Some("COVERAGE_TO_COLOR_LOCATION_NV"), + Self::COVERAGE_MODULATION_MODE_NV => Some("COVERAGE_MODULATION_MODE_NV"), + Self::COVERAGE_MODULATION_TABLE_ENABLE_NV => { + Some("COVERAGE_MODULATION_TABLE_ENABLE_NV") + } + Self::COVERAGE_MODULATION_TABLE_NV => Some("COVERAGE_MODULATION_TABLE_NV"), + Self::SHADING_RATE_IMAGE_ENABLE_NV => Some("SHADING_RATE_IMAGE_ENABLE_NV"), + Self::REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV => { + Some("REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV") + } + Self::COVERAGE_REDUCTION_MODE_NV => Some("COVERAGE_REDUCTION_MODE_NV"), + Self::CULL_MODE => Some("CULL_MODE"), + Self::FRONT_FACE => Some("FRONT_FACE"), + Self::PRIMITIVE_TOPOLOGY => Some("PRIMITIVE_TOPOLOGY"), + Self::VIEWPORT_WITH_COUNT => Some("VIEWPORT_WITH_COUNT"), + Self::SCISSOR_WITH_COUNT => Some("SCISSOR_WITH_COUNT"), + Self::VERTEX_INPUT_BINDING_STRIDE => Some("VERTEX_INPUT_BINDING_STRIDE"), + Self::DEPTH_TEST_ENABLE => Some("DEPTH_TEST_ENABLE"), + Self::DEPTH_WRITE_ENABLE => Some("DEPTH_WRITE_ENABLE"), + Self::DEPTH_COMPARE_OP => Some("DEPTH_COMPARE_OP"), + Self::DEPTH_BOUNDS_TEST_ENABLE => Some("DEPTH_BOUNDS_TEST_ENABLE"), + Self::STENCIL_TEST_ENABLE => Some("STENCIL_TEST_ENABLE"), + Self::STENCIL_OP => Some("STENCIL_OP"), + Self::RASTERIZER_DISCARD_ENABLE => Some("RASTERIZER_DISCARD_ENABLE"), + Self::DEPTH_BIAS_ENABLE => Some("DEPTH_BIAS_ENABLE"), + Self::PRIMITIVE_RESTART_ENABLE => Some("PRIMITIVE_RESTART_ENABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for EventCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(EventCreateFlags::DEVICE_ONLY.0, "DEVICE_ONLY")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExportMetalObjectTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExportMetalObjectTypeFlagsEXT::METAL_DEVICE.0, + "METAL_DEVICE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_COMMAND_QUEUE.0, + "METAL_COMMAND_QUEUE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_BUFFER.0, + "METAL_BUFFER", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_TEXTURE.0, + "METAL_TEXTURE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_IOSURFACE.0, + "METAL_IOSURFACE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_SHARED_EVENT.0, + "METAL_SHARED_EVENT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalFenceFeatureFlags::EXPORTABLE.0, "EXPORTABLE"), + (ExternalFenceFeatureFlags::IMPORTABLE.0, "IMPORTABLE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalFenceHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"), + (ExternalFenceHandleTypeFlags::OPAQUE_WIN32.0, "OPAQUE_WIN32"), + ( + ExternalFenceHandleTypeFlags::OPAQUE_WIN32_KMT.0, + "OPAQUE_WIN32_KMT", + ), + (ExternalFenceHandleTypeFlags::SYNC_FD.0, "SYNC_FD"), + ( + ExternalFenceHandleTypeFlags::RESERVED_4_NV.0, + "RESERVED_4_NV", + ), + ( + ExternalFenceHandleTypeFlags::RESERVED_5_NV.0, + "RESERVED_5_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::DEDICATED_ONLY.0, + "DEDICATED_ONLY", + ), + (ExternalMemoryFeatureFlags::EXPORTABLE.0, "EXPORTABLE"), + (ExternalMemoryFeatureFlags::IMPORTABLE.0, "IMPORTABLE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::DEDICATED_ONLY.0, + "DEDICATED_ONLY", + ), + (ExternalMemoryFeatureFlagsNV::EXPORTABLE.0, "EXPORTABLE"), + (ExternalMemoryFeatureFlagsNV::IMPORTABLE.0, "IMPORTABLE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalMemoryHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"), + ( + ExternalMemoryHandleTypeFlags::OPAQUE_WIN32.0, + "OPAQUE_WIN32", + ), + ( + ExternalMemoryHandleTypeFlags::OPAQUE_WIN32_KMT.0, + "OPAQUE_WIN32_KMT", + ), + ( + ExternalMemoryHandleTypeFlags::D3D11_TEXTURE.0, + "D3D11_TEXTURE", + ), + ( + ExternalMemoryHandleTypeFlags::D3D11_TEXTURE_KMT.0, + "D3D11_TEXTURE_KMT", + ), + (ExternalMemoryHandleTypeFlags::D3D12_HEAP.0, "D3D12_HEAP"), + ( + ExternalMemoryHandleTypeFlags::D3D12_RESOURCE.0, + "D3D12_RESOURCE", + ), + (ExternalMemoryHandleTypeFlags::DMA_BUF_EXT.0, "DMA_BUF_EXT"), + ( + ExternalMemoryHandleTypeFlags::ANDROID_HARDWARE_BUFFER_ANDROID.0, + "ANDROID_HARDWARE_BUFFER_ANDROID", + ), + ( + ExternalMemoryHandleTypeFlags::HOST_ALLOCATION_EXT.0, + "HOST_ALLOCATION_EXT", + ), + ( + ExternalMemoryHandleTypeFlags::HOST_MAPPED_FOREIGN_MEMORY_EXT.0, + "HOST_MAPPED_FOREIGN_MEMORY_EXT", + ), + ( + ExternalMemoryHandleTypeFlags::ZIRCON_VMO_FUCHSIA.0, + "ZIRCON_VMO_FUCHSIA", + ), + ( + ExternalMemoryHandleTypeFlags::RDMA_ADDRESS_NV.0, + "RDMA_ADDRESS_NV", + ), + ( + ExternalMemoryHandleTypeFlags::RESERVED_13_NV.0, + "RESERVED_13_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::OPAQUE_WIN32.0, + "OPAQUE_WIN32", + ), + ( + ExternalMemoryHandleTypeFlagsNV::OPAQUE_WIN32_KMT.0, + "OPAQUE_WIN32_KMT", + ), + ( + ExternalMemoryHandleTypeFlagsNV::D3D11_IMAGE.0, + "D3D11_IMAGE", + ), + ( + ExternalMemoryHandleTypeFlagsNV::D3D11_IMAGE_KMT.0, + "D3D11_IMAGE_KMT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalSemaphoreFeatureFlags::EXPORTABLE.0, "EXPORTABLE"), + (ExternalSemaphoreFeatureFlags::IMPORTABLE.0, "IMPORTABLE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalSemaphoreHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"), + ( + ExternalSemaphoreHandleTypeFlags::OPAQUE_WIN32.0, + "OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::OPAQUE_WIN32_KMT.0, + "OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::D3D12_FENCE.0, + "D3D12_FENCE", + ), + (ExternalSemaphoreHandleTypeFlags::SYNC_FD.0, "SYNC_FD"), + ( + ExternalSemaphoreHandleTypeFlags::ZIRCON_EVENT_FUCHSIA.0, + "ZIRCON_EVENT_FUCHSIA", + ), + ( + ExternalSemaphoreHandleTypeFlags::RESERVED_5_NV.0, + "RESERVED_5_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_EXT => Some("CUBIC_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::ASTC_3X3X3_UNORM_BLOCK_EXT => Some("ASTC_3X3X3_UNORM_BLOCK_EXT"), + Self::ASTC_3X3X3_SRGB_BLOCK_EXT => Some("ASTC_3X3X3_SRGB_BLOCK_EXT"), + Self::ASTC_3X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_3X3X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X3X3_UNORM_BLOCK_EXT => Some("ASTC_4X3X3_UNORM_BLOCK_EXT"), + Self::ASTC_4X3X3_SRGB_BLOCK_EXT => Some("ASTC_4X3X3_SRGB_BLOCK_EXT"), + Self::ASTC_4X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X3X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X4X3_UNORM_BLOCK_EXT => Some("ASTC_4X4X3_UNORM_BLOCK_EXT"), + Self::ASTC_4X4X3_SRGB_BLOCK_EXT => Some("ASTC_4X4X3_SRGB_BLOCK_EXT"), + Self::ASTC_4X4X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X4X4_UNORM_BLOCK_EXT => Some("ASTC_4X4X4_UNORM_BLOCK_EXT"), + Self::ASTC_4X4X4_SRGB_BLOCK_EXT => Some("ASTC_4X4X4_SRGB_BLOCK_EXT"), + Self::ASTC_4X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X4X4_UNORM_BLOCK_EXT => Some("ASTC_5X4X4_UNORM_BLOCK_EXT"), + Self::ASTC_5X4X4_SRGB_BLOCK_EXT => Some("ASTC_5X4X4_SRGB_BLOCK_EXT"), + Self::ASTC_5X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X4X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X5X4_UNORM_BLOCK_EXT => Some("ASTC_5X5X4_UNORM_BLOCK_EXT"), + Self::ASTC_5X5X4_SRGB_BLOCK_EXT => Some("ASTC_5X5X4_SRGB_BLOCK_EXT"), + Self::ASTC_5X5X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X5X5_UNORM_BLOCK_EXT => Some("ASTC_5X5X5_UNORM_BLOCK_EXT"), + Self::ASTC_5X5X5_SRGB_BLOCK_EXT => Some("ASTC_5X5X5_SRGB_BLOCK_EXT"), + Self::ASTC_5X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X5X5_UNORM_BLOCK_EXT => Some("ASTC_6X5X5_UNORM_BLOCK_EXT"), + Self::ASTC_6X5X5_SRGB_BLOCK_EXT => Some("ASTC_6X5X5_SRGB_BLOCK_EXT"), + Self::ASTC_6X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X5X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X6X5_UNORM_BLOCK_EXT => Some("ASTC_6X6X5_UNORM_BLOCK_EXT"), + Self::ASTC_6X6X5_SRGB_BLOCK_EXT => Some("ASTC_6X6X5_SRGB_BLOCK_EXT"), + Self::ASTC_6X6X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X6X6_UNORM_BLOCK_EXT => Some("ASTC_6X6X6_UNORM_BLOCK_EXT"), + Self::ASTC_6X6X6_SRGB_BLOCK_EXT => Some("ASTC_6X6X6_SRGB_BLOCK_EXT"), + Self::ASTC_6X6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X6_SFLOAT_BLOCK_EXT"), + Self::R16G16_S10_5_NV => Some("R16G16_S10_5_NV"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + Self::G8_B8R8_2PLANE_444_UNORM => Some("G8_B8R8_2PLANE_444_UNORM"), + Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16") + } + Self::G16_B16R16_2PLANE_444_UNORM => Some("G16_B16R16_2PLANE_444_UNORM"), + Self::A4R4G4B4_UNORM_PACK16 => Some("A4R4G4B4_UNORM_PACK16"), + Self::A4B4G4R4_UNORM_PACK16 => Some("A4B4G4R4_UNORM_PACK16"), + Self::ASTC_4X4_SFLOAT_BLOCK => Some("ASTC_4X4_SFLOAT_BLOCK"), + Self::ASTC_5X4_SFLOAT_BLOCK => Some("ASTC_5X4_SFLOAT_BLOCK"), + Self::ASTC_5X5_SFLOAT_BLOCK => Some("ASTC_5X5_SFLOAT_BLOCK"), + Self::ASTC_6X5_SFLOAT_BLOCK => Some("ASTC_6X5_SFLOAT_BLOCK"), + Self::ASTC_6X6_SFLOAT_BLOCK => Some("ASTC_6X6_SFLOAT_BLOCK"), + Self::ASTC_8X5_SFLOAT_BLOCK => Some("ASTC_8X5_SFLOAT_BLOCK"), + Self::ASTC_8X6_SFLOAT_BLOCK => Some("ASTC_8X6_SFLOAT_BLOCK"), + Self::ASTC_8X8_SFLOAT_BLOCK => Some("ASTC_8X8_SFLOAT_BLOCK"), + Self::ASTC_10X5_SFLOAT_BLOCK => Some("ASTC_10X5_SFLOAT_BLOCK"), + Self::ASTC_10X6_SFLOAT_BLOCK => Some("ASTC_10X6_SFLOAT_BLOCK"), + Self::ASTC_10X8_SFLOAT_BLOCK => Some("ASTC_10X8_SFLOAT_BLOCK"), + Self::ASTC_10X10_SFLOAT_BLOCK => Some("ASTC_10X10_SFLOAT_BLOCK"), + Self::ASTC_12X10_SFLOAT_BLOCK => Some("ASTC_12X10_SFLOAT_BLOCK"), + Self::ASTC_12X12_SFLOAT_BLOCK => Some("ASTC_12X12_SFLOAT_BLOCK"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [(Flags , & str)] = & [(FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_EXT . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_EXT") , (FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX")] ; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FormatFeatureFlags2 { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: RESERVED_44_EXT . 0 , "RESERVED_44_EXT") , (FormatFeatureFlags2 :: RESERVED_45_EXT . 0 , "RESERVED_45_EXT") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: RESERVED_39_EXT . 0 , "RESERVED_39_EXT") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV")] ; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FragmentShadingRateCombinerOpKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::REPLACE => Some("REPLACE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::MUL => Some("MUL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FragmentShadingRateNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FragmentShadingRateTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FRAGMENT_SIZE => Some("FRAGMENT_SIZE"), + Self::ENUMS => Some("ENUMS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FramebufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FramebufferCreateFlags::IMAGELESS.0, "IMAGELESS")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FullScreenExclusiveEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + Self::APPLICATION_CONTROLLED => Some("APPLICATION_CONTROLLED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for GeometryFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsKHR::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsKHR::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for GeometryInstanceFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsKHR::TRIANGLE_FACING_CULL_DISABLE.0, + "TRIANGLE_FACING_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsKHR::TRIANGLE_FLIP_FACING.0, + "TRIANGLE_FLIP_FACING", + ), + (GeometryInstanceFlagsKHR::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsKHR::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ( + GeometryInstanceFlagsKHR::FORCE_OPACITY_MICROMAP_2_STATE_EXT.0, + "FORCE_OPACITY_MICROMAP_2_STATE_EXT", + ), + ( + GeometryInstanceFlagsKHR::DISABLE_OPACITY_MICROMAPS_EXT.0, + "DISABLE_OPACITY_MICROMAPS_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for GeometryTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), + Self::INSTANCES => Some("INSTANCES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for GraphicsPipelineLibraryFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GraphicsPipelineLibraryFlagsEXT::VERTEX_INPUT_INTERFACE.0, + "VERTEX_INPUT_INTERFACE", + ), + ( + GraphicsPipelineLibraryFlagsEXT::PRE_RASTERIZATION_SHADERS.0, + "PRE_RASTERIZATION_SHADERS", + ), + ( + GraphicsPipelineLibraryFlagsEXT::FRAGMENT_SHADER.0, + "FRAGMENT_SHADER", + ), + ( + GraphicsPipelineLibraryFlagsEXT::FRAGMENT_OUTPUT_INTERFACE.0, + "FRAGMENT_OUTPUT_INTERFACE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for HeadlessSurfaceCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for IOSSurfaceCreateFlagsMVK { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + (ImageAspectFlags::NONE.0, "NONE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageCompressionFixedRateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCompressionFixedRateFlagsEXT::NONE.0, "NONE"), + (ImageCompressionFixedRateFlagsEXT::TYPE_1BPC.0, "TYPE_1BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_2BPC.0, "TYPE_2BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_3BPC.0, "TYPE_3BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_4BPC.0, "TYPE_4BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_5BPC.0, "TYPE_5BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_6BPC.0, "TYPE_6BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_7BPC.0, "TYPE_7BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_8BPC.0, "TYPE_8BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_9BPC.0, "TYPE_9BPC"), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_10BPC.0, + "TYPE_10BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_11BPC.0, + "TYPE_11BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_12BPC.0, + "TYPE_12BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_13BPC.0, + "TYPE_13BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_14BPC.0, + "TYPE_14BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_15BPC.0, + "TYPE_15BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_16BPC.0, + "TYPE_16BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_17BPC.0, + "TYPE_17BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_18BPC.0, + "TYPE_18BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_19BPC.0, + "TYPE_19BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_20BPC.0, + "TYPE_20BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_21BPC.0, + "TYPE_21BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_22BPC.0, + "TYPE_22BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_23BPC.0, + "TYPE_23BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_24BPC.0, + "TYPE_24BPC", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageCompressionFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCompressionFlagsEXT::DEFAULT.0, "DEFAULT"), + ( + ImageCompressionFlagsEXT::FIXED_RATE_DEFAULT.0, + "FIXED_RATE_DEFAULT", + ), + ( + ImageCompressionFlagsEXT::FIXED_RATE_EXPLICIT.0, + "FIXED_RATE_EXPLICIT", + ), + (ImageCompressionFlagsEXT::DISABLED.0, "DISABLED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageConstraintsInfoFlagsFUCHSIA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_RARELY.0, + "CPU_READ_RARELY", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_OFTEN.0, + "CPU_READ_OFTEN", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_RARELY.0, + "CPU_WRITE_RARELY", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_OFTEN.0, + "CPU_WRITE_OFTEN", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::PROTECTED_OPTIONAL.0, + "PROTECTED_OPTIONAL", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (ImageCreateFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"), + ( + ImageCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + ( + ImageCreateFlags::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT.0, + "MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT", + ), + ( + ImageCreateFlags::TYPE_2D_VIEW_COMPATIBLE_EXT.0, + "TYPE_2D_VIEW_COMPATIBLE_EXT", + ), + ( + ImageCreateFlags::FRAGMENT_DENSITY_MAP_OFFSET_QCOM.0, + "FRAGMENT_DENSITY_MAP_OFFSET_QCOM", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageFormatConstraintsFlagsFUCHSIA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::VIDEO_DECODE_DST_KHR => Some("VIDEO_DECODE_DST_KHR"), + Self::VIDEO_DECODE_SRC_KHR => Some("VIDEO_DECODE_SRC_KHR"), + Self::VIDEO_DECODE_DPB_KHR => Some("VIDEO_DECODE_DPB_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR => { + Some("FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR") + } + Self::VIDEO_ENCODE_DST_KHR => Some("VIDEO_ENCODE_DST_KHR"), + Self::VIDEO_ENCODE_SRC_KHR => Some("VIDEO_ENCODE_SRC_KHR"), + Self::VIDEO_ENCODE_DPB_KHR => Some("VIDEO_ENCODE_DPB_KHR"), + Self::ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT => { + Some("ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT") + } + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_OPTIMAL => Some("DEPTH_ATTACHMENT_OPTIMAL"), + Self::DEPTH_READ_ONLY_OPTIMAL => Some("DEPTH_READ_ONLY_OPTIMAL"), + Self::STENCIL_ATTACHMENT_OPTIMAL => Some("STENCIL_ATTACHMENT_OPTIMAL"), + Self::STENCIL_READ_ONLY_OPTIMAL => Some("STENCIL_READ_ONLY_OPTIMAL"), + Self::READ_ONLY_OPTIMAL => Some("READ_ONLY_OPTIMAL"), + Self::ATTACHMENT_OPTIMAL => Some("ATTACHMENT_OPTIMAL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ImagePipeSurfaceCreateFlagsFUCHSIA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ( + ImageUsageFlags::VIDEO_DECODE_DST_KHR.0, + "VIDEO_DECODE_DST_KHR", + ), + ( + ImageUsageFlags::VIDEO_DECODE_SRC_KHR.0, + "VIDEO_DECODE_SRC_KHR", + ), + ( + ImageUsageFlags::VIDEO_DECODE_DPB_KHR.0, + "VIDEO_DECODE_DPB_KHR", + ), + (ImageUsageFlags::RESERVED_16_QCOM.0, "RESERVED_16_QCOM"), + (ImageUsageFlags::RESERVED_17_QCOM.0, "RESERVED_17_QCOM"), + ( + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", + ), + ( + ImageUsageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + (ImageUsageFlags::RESERVED_22_EXT.0, "RESERVED_22_EXT"), + ( + ImageUsageFlags::VIDEO_ENCODE_DST_KHR.0, + "VIDEO_ENCODE_DST_KHR", + ), + ( + ImageUsageFlags::VIDEO_ENCODE_SRC_KHR.0, + "VIDEO_ENCODE_SRC_KHR", + ), + ( + ImageUsageFlags::VIDEO_ENCODE_DPB_KHR.0, + "VIDEO_ENCODE_DPB_KHR", + ), + ( + ImageUsageFlags::ATTACHMENT_FEEDBACK_LOOP_EXT.0, + "ATTACHMENT_FEEDBACK_LOOP_EXT", + ), + ( + ImageUsageFlags::INVOCATION_MASK_HUAWEI.0, + "INVOCATION_MASK_HUAWEI", + ), + (ImageUsageFlags::SAMPLE_WEIGHT_QCOM.0, "SAMPLE_WEIGHT_QCOM"), + ( + ImageUsageFlags::SAMPLE_BLOCK_MATCH_QCOM.0, + "SAMPLE_BLOCK_MATCH_QCOM", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageViewCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", + ), + ( + ImageViewCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + ( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0, + "FRAGMENT_DENSITY_MAP_DEFERRED_EXT", + ), + (ImageViewCreateFlags::RESERVED_3_EXT.0, "RESERVED_3_EXT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_KHR => Some("NONE_KHR"), + Self::UINT8_EXT => Some("UINT8_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for IndirectCommandsLayoutUsageFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNV::EXPLICIT_PREPROCESS.0, + "EXPLICIT_PREPROCESS", + ), + ( + IndirectCommandsLayoutUsageFlagsNV::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNV::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for IndirectCommandsTokenTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SHADER_GROUP => Some("SHADER_GROUP"), + Self::STATE_FLAGS => Some("STATE_FLAGS"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DRAW_TASKS => Some("DRAW_TASKS"), + Self::DRAW_MESH_TASKS => Some("DRAW_MESH_TASKS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for IndirectStateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(IndirectStateFlagsNV::FLAG_FRONTFACE.0, "FLAG_FRONTFACE")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for InstanceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR.0, + "ENUMERATE_PORTABILITY_KHR", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for LineRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::RECTANGULAR => Some("RECTANGULAR"), + Self::BRESENHAM => Some("BRESENHAM"), + Self::RECTANGULAR_SMOOTH => Some("RECTANGULAR_SMOOTH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for MacOSSurfaceCreateFlagsMVK { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK"), + (MemoryAllocateFlags::DEVICE_ADDRESS.0, "DEVICE_ADDRESS"), + ( + MemoryAllocateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryDecompressionMethodFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[( + MemoryDecompressionMethodFlagsNV::GDEFLATE_1_0.0, + "GDEFLATE_1_0", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::RESERVED_2_KHR.0, "RESERVED_2_KHR"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryMapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + ( + MemoryPropertyFlags::DEVICE_COHERENT_AMD.0, + "DEVICE_COHERENT_AMD", + ), + ( + MemoryPropertyFlags::DEVICE_UNCACHED_AMD.0, + "DEVICE_UNCACHED_AMD", + ), + (MemoryPropertyFlags::RDMA_CAPABLE_NV.0, "RDMA_CAPABLE_NV"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MetalSurfaceCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MicromapCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + MicromapCreateFlagsEXT::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MicromapTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPACITY_MICROMAP => Some("OPACITY_MICROMAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpacityMicromapFormatEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_2_STATE => Some("TYPE_2_STATE"), + Self::TYPE_4_STATE => Some("TYPE_4_STATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpacityMicromapSpecialIndexEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FULLY_TRANSPARENT => Some("FULLY_TRANSPARENT"), + Self::FULLY_OPAQUE => Some("FULLY_OPAQUE"), + Self::FULLY_UNKNOWN_TRANSPARENT => Some("FULLY_UNKNOWN_TRANSPARENT"), + Self::FULLY_UNKNOWN_OPAQUE => Some("FULLY_UNKNOWN_OPAQUE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowExecuteFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + OpticalFlowExecuteFlagsNV::DISABLE_TEMPORAL_HINTS.0, + "DISABLE_TEMPORAL_HINTS", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowGridSizeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (OpticalFlowGridSizeFlagsNV::UNKNOWN.0, "UNKNOWN"), + (OpticalFlowGridSizeFlagsNV::TYPE_1X1.0, "TYPE_1X1"), + (OpticalFlowGridSizeFlagsNV::TYPE_2X2.0, "TYPE_2X2"), + (OpticalFlowGridSizeFlagsNV::TYPE_4X4.0, "TYPE_4X4"), + (OpticalFlowGridSizeFlagsNV::TYPE_8X8.0, "TYPE_8X8"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowPerformanceLevelNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::SLOW => Some("SLOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::FAST => Some("FAST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowSessionBindingPointNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INPUT => Some("INPUT"), + Self::REFERENCE => Some("REFERENCE"), + Self::HINT => Some("HINT"), + Self::FLOW_VECTOR => Some("FLOW_VECTOR"), + Self::BACKWARD_FLOW_VECTOR => Some("BACKWARD_FLOW_VECTOR"), + Self::COST => Some("COST"), + Self::BACKWARD_COST => Some("BACKWARD_COST"), + Self::GLOBAL_FLOW => Some("GLOBAL_FLOW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowSessionCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_HINT.0, + "ENABLE_HINT", + ), + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_COST.0, + "ENABLE_COST", + ), + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_GLOBAL_FLOW.0, + "ENABLE_GLOBAL_FLOW", + ), + ( + OpticalFlowSessionCreateFlagsNV::ALLOW_REGIONS.0, + "ALLOW_REGIONS", + ), + ( + OpticalFlowSessionCreateFlagsNV::BOTH_DIRECTIONS.0, + "BOTH_DIRECTIONS", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowUsageFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (OpticalFlowUsageFlagsNV::UNKNOWN.0, "UNKNOWN"), + (OpticalFlowUsageFlagsNV::INPUT.0, "INPUT"), + (OpticalFlowUsageFlagsNV::OUTPUT.0, "OUTPUT"), + (OpticalFlowUsageFlagsNV::HINT.0, "HINT"), + (OpticalFlowUsageFlagsNV::COST.0, "COST"), + (OpticalFlowUsageFlagsNV::GLOBAL_FLOW.0, "GLOBAL_FLOW"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PerformanceConfigurationTypeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED => { + Some("COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceCounterDescriptionFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PerformanceCounterDescriptionFlagsKHR::PERFORMANCE_IMPACTING.0, + "PERFORMANCE_IMPACTING", + ), + ( + PerformanceCounterDescriptionFlagsKHR::CONCURRENTLY_IMPACTED.0, + "CONCURRENTLY_IMPACTED", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PerformanceCounterScopeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::COMMAND => Some("COMMAND"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceCounterStorageKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INT32 => Some("INT32"), + Self::INT64 => Some("INT64"), + Self::UINT32 => Some("UINT32"), + Self::UINT64 => Some("UINT64"), + Self::FLOAT32 => Some("FLOAT32"), + Self::FLOAT64 => Some("FLOAT64"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceCounterUnitKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERIC => Some("GENERIC"), + Self::PERCENTAGE => Some("PERCENTAGE"), + Self::NANOSECONDS => Some("NANOSECONDS"), + Self::BYTES => Some("BYTES"), + Self::BYTES_PER_SECOND => Some("BYTES_PER_SECOND"), + Self::KELVIN => Some("KELVIN"), + Self::WATTS => Some("WATTS"), + Self::VOLTS => Some("VOLTS"), + Self::AMPS => Some("AMPS"), + Self::HERTZ => Some("HERTZ"), + Self::CYCLES => Some("CYCLES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceOverrideTypeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NULL_HARDWARE => Some("NULL_HARDWARE"), + Self::FLUSH_GPU_CACHES => Some("FLUSH_GPU_CACHES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceParameterTypeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::HW_COUNTERS_SUPPORTED => Some("HW_COUNTERS_SUPPORTED"), + Self::STREAM_MARKER_VALIDS => Some("STREAM_MARKER_VALIDS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceValueTypeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT32 => Some("UINT32"), + Self::UINT64 => Some("UINT64"), + Self::FLOAT => Some("FLOAT"), + Self::BOOL => Some("BOOL"), + Self::STRING => Some("STRING"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_KHR => Some("RAY_TRACING_KHR"), + Self::SUBPASS_SHADING_HUAWEI => Some("SUBPASS_SHADING_HUAWEI"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineCacheCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineCacheCreateFlags::RESERVED_1_EXT.0, "RESERVED_1_EXT"), + (PipelineCacheCreateFlags::RESERVED_2_KHR.0, "RESERVED_2_KHR"), + ( + PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED.0, + "EXTERNALLY_SYNCHRONIZED", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineColorBlendStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + PipelineColorBlendStateCreateFlags::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT.0, + "RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCompilerControlFlagsAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCoverageModulationStateCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCoverageReductionStateCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCoverageToColorStateCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + ( + PipelineCreateFlags::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0, + "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT", + ), + ( + PipelineCreateFlags::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0, + "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR.0, + "RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_NO_NULL_MISS_SHADERS_KHR.0, + "RAY_TRACING_NO_NULL_MISS_SHADERS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR.0, + "RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_SKIP_TRIANGLES_KHR.0, + "RAY_TRACING_SKIP_TRIANGLES_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_SKIP_AABBS_KHR.0, + "RAY_TRACING_SKIP_AABBS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR.0, + "RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR", + ), + (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), + ( + PipelineCreateFlags::CAPTURE_STATISTICS_KHR.0, + "CAPTURE_STATISTICS_KHR", + ), + ( + PipelineCreateFlags::CAPTURE_INTERNAL_REPRESENTATIONS_KHR.0, + "CAPTURE_INTERNAL_REPRESENTATIONS_KHR", + ), + ( + PipelineCreateFlags::INDIRECT_BINDABLE_NV.0, + "INDIRECT_BINDABLE_NV", + ), + (PipelineCreateFlags::LIBRARY_KHR.0, "LIBRARY_KHR"), + ( + PipelineCreateFlags::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", + ), + ( + PipelineCreateFlags::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT.0, + "RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT", + ), + ( + PipelineCreateFlags::LINK_TIME_OPTIMIZATION_EXT.0, + "LINK_TIME_OPTIMIZATION_EXT", + ), + ( + PipelineCreateFlags::RAY_TRACING_ALLOW_MOTION_NV.0, + "RAY_TRACING_ALLOW_MOTION_NV", + ), + ( + PipelineCreateFlags::COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT.0, + "COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT", + ), + ( + PipelineCreateFlags::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT.0, + "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT", + ), + ( + PipelineCreateFlags::RAY_TRACING_OPACITY_MICROMAP_EXT.0, + "RAY_TRACING_OPACITY_MICROMAP_EXT", + ), + (PipelineCreateFlags::RESERVED_28_NV.0, "RESERVED_28_NV"), + ( + PipelineCreateFlags::NO_PROTECTED_ACCESS_EXT.0, + "NO_PROTECTED_ACCESS_EXT", + ), + ( + PipelineCreateFlags::PROTECTED_ACCESS_ONLY_EXT.0, + "PROTECTED_ACCESS_ONLY_EXT", + ), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ( + PipelineCreateFlags::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0, + "FAIL_ON_PIPELINE_COMPILE_REQUIRED", + ), + ( + PipelineCreateFlags::EARLY_RETURN_ON_FAILURE.0, + "EARLY_RETURN_ON_FAILURE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCreationFeedbackFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineCreationFeedbackFlags::VALID.0, "VALID"), + ( + PipelineCreationFeedbackFlags::APPLICATION_PIPELINE_CACHE_HIT.0, + "APPLICATION_PIPELINE_CACHE_HIT", + ), + ( + PipelineCreationFeedbackFlags::BASE_PIPELINE_ACCELERATION.0, + "BASE_PIPELINE_ACCELERATION", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineDepthStencilStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [(Flags , & str)] = & [(PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT . 0 , "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT") , (PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT . 0 , "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT")] ; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineDiscardRectangleStateCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineDynamicStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineExecutableStatisticFormatKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BOOL32 => Some("BOOL32"), + Self::INT64 => Some("INT64"), + Self::UINT64 => Some("UINT64"), + Self::FLOAT64 => Some("FLOAT64"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineInputAssemblyStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineLayoutCreateFlags::RESERVED_0_AMD.0, + "RESERVED_0_AMD", + ), + ( + PipelineLayoutCreateFlags::INDEPENDENT_SETS_EXT.0, + "INDEPENDENT_SETS_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineMultisampleStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRasterizationConservativeStateCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRasterizationDepthClipStateCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRasterizationStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRasterizationStateStreamCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRobustnessBufferBehaviorEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE_DEFAULT => Some("DEVICE_DEFAULT"), + Self::DISABLED => Some("DISABLED"), + Self::ROBUST_BUFFER_ACCESS => Some("ROBUST_BUFFER_ACCESS"), + Self::ROBUST_BUFFER_ACCESS_2 => Some("ROBUST_BUFFER_ACCESS_2"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineRobustnessImageBehaviorEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE_DEFAULT => Some("DEVICE_DEFAULT"), + Self::DISABLED => Some("DISABLED"), + Self::ROBUST_IMAGE_ACCESS => Some("ROBUST_IMAGE_ACCESS"), + Self::ROBUST_IMAGE_ACCESS_2 => Some("ROBUST_IMAGE_ACCESS_2"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineShaderStageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineShaderStageCreateFlags::RESERVED_3_KHR.0, + "RESERVED_3_KHR", + ), + ( + PipelineShaderStageCreateFlags::ALLOW_VARYING_SUBGROUP_SIZE.0, + "ALLOW_VARYING_SUBGROUP_SIZE", + ), + ( + PipelineShaderStageCreateFlags::REQUIRE_FULL_SUBGROUPS.0, + "REQUIRE_FULL_SUBGROUPS", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, + "TRANSFORM_FEEDBACK_EXT", + ), + ( + PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + ( + PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR.0, + "ACCELERATION_STRUCTURE_BUILD_KHR", + ), + ( + PipelineStageFlags::RAY_TRACING_SHADER_KHR.0, + "RAY_TRACING_SHADER_KHR", + ), + ( + PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, + "FRAGMENT_DENSITY_PROCESS_EXT", + ), + ( + PipelineStageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + ( + PipelineStageFlags::COMMAND_PREPROCESS_NV.0, + "COMMAND_PREPROCESS_NV", + ), + (PipelineStageFlags::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"), + (PipelineStageFlags::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"), + (PipelineStageFlags::NONE.0, "NONE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineStageFlags2 { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[ + (PipelineStageFlags2::NONE.0, "NONE"), + (PipelineStageFlags2::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags2::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags2::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags2::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags2::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags2::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags2::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags2::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags2::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags2::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags2::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags2::ALL_TRANSFER.0, "ALL_TRANSFER"), + (PipelineStageFlags2::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags2::HOST.0, "HOST"), + (PipelineStageFlags2::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags2::ALL_COMMANDS.0, "ALL_COMMANDS"), + (PipelineStageFlags2::COPY.0, "COPY"), + (PipelineStageFlags2::RESOLVE.0, "RESOLVE"), + (PipelineStageFlags2::BLIT.0, "BLIT"), + (PipelineStageFlags2::CLEAR.0, "CLEAR"), + (PipelineStageFlags2::INDEX_INPUT.0, "INDEX_INPUT"), + ( + PipelineStageFlags2::VERTEX_ATTRIBUTE_INPUT.0, + "VERTEX_ATTRIBUTE_INPUT", + ), + ( + PipelineStageFlags2::PRE_RASTERIZATION_SHADERS.0, + "PRE_RASTERIZATION_SHADERS", + ), + (PipelineStageFlags2::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"), + (PipelineStageFlags2::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"), + ( + PipelineStageFlags2::TRANSFORM_FEEDBACK_EXT.0, + "TRANSFORM_FEEDBACK_EXT", + ), + ( + PipelineStageFlags2::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + ( + PipelineStageFlags2::COMMAND_PREPROCESS_NV.0, + "COMMAND_PREPROCESS_NV", + ), + ( + PipelineStageFlags2::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + ( + PipelineStageFlags2::ACCELERATION_STRUCTURE_BUILD_KHR.0, + "ACCELERATION_STRUCTURE_BUILD_KHR", + ), + ( + PipelineStageFlags2::RAY_TRACING_SHADER_KHR.0, + "RAY_TRACING_SHADER_KHR", + ), + ( + PipelineStageFlags2::FRAGMENT_DENSITY_PROCESS_EXT.0, + "FRAGMENT_DENSITY_PROCESS_EXT", + ), + (PipelineStageFlags2::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"), + (PipelineStageFlags2::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"), + ( + PipelineStageFlags2::SUBPASS_SHADING_HUAWEI.0, + "SUBPASS_SHADING_HUAWEI", + ), + ( + PipelineStageFlags2::INVOCATION_MASK_HUAWEI.0, + "INVOCATION_MASK_HUAWEI", + ), + ( + PipelineStageFlags2::ACCELERATION_STRUCTURE_COPY_KHR.0, + "ACCELERATION_STRUCTURE_COPY_KHR", + ), + ( + PipelineStageFlags2::MICROMAP_BUILD_EXT.0, + "MICROMAP_BUILD_EXT", + ), + ( + PipelineStageFlags2::RESEVED_41_HUAWEI.0, + "RESEVED_41_HUAWEI", + ), + (PipelineStageFlags2::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineTessellationStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineVertexInputStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineViewportStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineViewportSwizzleStateCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PresentGravityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PresentGravityFlagsEXT::MIN.0, "MIN"), + (PresentGravityFlagsEXT::MAX.0, "MAX"), + (PresentGravityFlagsEXT::CENTERED.0, "CENTERED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PresentScalingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PresentScalingFlagsEXT::ONE_TO_ONE.0, "ONE_TO_ONE"), + ( + PresentScalingFlagsEXT::ASPECT_RATIO_STRETCH.0, + "ASPECT_RATIO_STRETCH", + ), + (PresentScalingFlagsEXT::STRETCH.0, "STRETCH"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PrivateDataSlotCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ProvokingVertexModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_VERTEX => Some("FIRST_VERTEX"), + Self::LAST_VERTEX => Some("LAST_VERTEX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TASK_SHADER_INVOCATIONS_EXT.0, + "TASK_SHADER_INVOCATIONS_EXT", + ), + ( + QueryPipelineStatisticFlags::MESH_SHADER_INVOCATIONS_EXT.0, + "MESH_SHADER_INVOCATIONS_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueryPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueryPoolSamplingModeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::MANUAL => Some("MANUAL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + (QueryResultFlags::WITH_STATUS_KHR.0, "WITH_STATUS_KHR"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueryResultStatusKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ERROR => Some("ERROR"), + Self::NOT_READY => Some("NOT_READY"), + Self::COMPLETE => Some("COMPLETE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESULT_STATUS_ONLY_KHR => Some("RESULT_STATUS_ONLY_KHR"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::PERFORMANCE_QUERY_KHR => Some("PERFORMANCE_QUERY_KHR"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR") + } + Self::ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR => { + Some("ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR") + } + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"), + Self::VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR => { + Some("VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR") + } + Self::MESH_PRIMITIVES_GENERATED_EXT => Some("MESH_PRIMITIVES_GENERATED_EXT"), + Self::PRIMITIVES_GENERATED_EXT => Some("PRIMITIVES_GENERATED_EXT"), + Self::ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR => { + Some("ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR") + } + Self::ACCELERATION_STRUCTURE_SIZE_KHR => Some("ACCELERATION_STRUCTURE_SIZE_KHR"), + Self::MICROMAP_SERIALIZATION_SIZE_EXT => Some("MICROMAP_SERIALIZATION_SIZE_EXT"), + Self::MICROMAP_COMPACTED_SIZE_EXT => Some("MICROMAP_COMPACTED_SIZE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"), + (QueueFlags::RESERVED_9_EXT.0, "RESERVED_9_EXT"), + (QueueFlags::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"), + (QueueFlags::RESERVED_7_QCOM.0, "RESERVED_7_QCOM"), + (QueueFlags::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueueGlobalPriorityKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for RayTracingInvocationReorderModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::REORDER => Some("REORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for RayTracingShaderGroupTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR"), + (RenderPassCreateFlags::TRANSFORM_QCOM.0, "TRANSFORM_QCOM"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for RenderingFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + RenderingFlags::CONTENTS_SECONDARY_COMMAND_BUFFERS.0, + "CONTENTS_SECONDARY_COMMAND_BUFFERS", + ), + (RenderingFlags::SUSPENDING.0, "SUSPENDING"), + (RenderingFlags::RESUMING.0, "RESUMING"), + ( + RenderingFlags::ENABLE_LEGACY_DITHERING_EXT.0, + "ENABLE_LEGACY_DITHERING_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ResolveModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ResolveModeFlags::NONE.0, "NONE"), + (ResolveModeFlags::SAMPLE_ZERO.0, "SAMPLE_ZERO"), + (ResolveModeFlags::AVERAGE.0, "AVERAGE"), + (ResolveModeFlags::MIN.0, "MIN"), + (ResolveModeFlags::MAX.0, "MAX"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::MIRROR_CLAMP_TO_EDGE => Some("MIRROR_CLAMP_TO_EDGE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SamplerCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + ( + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + ), + ( + SamplerCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + ( + SamplerCreateFlags::NON_SEAMLESS_CUBE_MAP_EXT.0, + "NON_SEAMLESS_CUBE_MAP_EXT", + ), + ( + SamplerCreateFlags::IMAGE_PROCESSING_QCOM.0, + "IMAGE_PROCESSING_QCOM", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SamplerReductionMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ScopeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::WORKGROUP => Some("WORKGROUP"), + Self::SUBGROUP => Some("SUBGROUP"), + Self::QUEUE_FAMILY => Some("QUEUE_FAMILY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ScreenSurfaceCreateFlagsQNX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SemaphoreCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SemaphoreType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BINARY => Some("BINARY"), + Self::TIMELINE => Some("TIMELINE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SemaphoreWaitFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreWaitFlags::ANY.0, "ANY")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ShaderCorePropertiesFlagsAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ShaderFloatControlsIndependence { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_32_ONLY => Some("TYPE_32_ONLY"), + Self::ALL => Some("ALL"), + Self::NONE => Some("NONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ShaderGroupShaderKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::CLOSEST_HIT => Some("CLOSEST_HIT"), + Self::ANY_HIT => Some("ANY_HIT"), + Self::INTERSECTION => Some("INTERSECTION"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ShaderModuleCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + (ShaderStageFlags::RAYGEN_KHR.0, "RAYGEN_KHR"), + (ShaderStageFlags::ANY_HIT_KHR.0, "ANY_HIT_KHR"), + (ShaderStageFlags::CLOSEST_HIT_KHR.0, "CLOSEST_HIT_KHR"), + (ShaderStageFlags::MISS_KHR.0, "MISS_KHR"), + (ShaderStageFlags::INTERSECTION_KHR.0, "INTERSECTION_KHR"), + (ShaderStageFlags::CALLABLE_KHR.0, "CALLABLE_KHR"), + (ShaderStageFlags::TASK_EXT.0, "TASK_EXT"), + (ShaderStageFlags::MESH_EXT.0, "MESH_EXT"), + ( + ShaderStageFlags::SUBPASS_SHADING_HUAWEI.0, + "SUBPASS_SHADING_HUAWEI", + ), + (ShaderStageFlags::RESERVED_19_HUAWEI.0, "RESERVED_19_HUAWEI"), + (ShaderStageFlags::EXT_483_RESERVE_15.0, "EXT_483_RESERVE_15"), + (ShaderStageFlags::EXT_483_RESERVE_16.0, "EXT_483_RESERVE_16"), + (ShaderStageFlags::EXT_483_RESERVE_17.0, "EXT_483_RESERVE_17"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ShadingRatePaletteEntryNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + (StencilFaceFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for StreamDescriptorSurfaceCreateFlagsGGP { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for StructureType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::APPLICATION_INFO => Some("APPLICATION_INFO"), + Self::INSTANCE_CREATE_INFO => Some("INSTANCE_CREATE_INFO"), + Self::DEVICE_QUEUE_CREATE_INFO => Some("DEVICE_QUEUE_CREATE_INFO"), + Self::DEVICE_CREATE_INFO => Some("DEVICE_CREATE_INFO"), + Self::SUBMIT_INFO => Some("SUBMIT_INFO"), + Self::MEMORY_ALLOCATE_INFO => Some("MEMORY_ALLOCATE_INFO"), + Self::MAPPED_MEMORY_RANGE => Some("MAPPED_MEMORY_RANGE"), + Self::BIND_SPARSE_INFO => Some("BIND_SPARSE_INFO"), + Self::FENCE_CREATE_INFO => Some("FENCE_CREATE_INFO"), + Self::SEMAPHORE_CREATE_INFO => Some("SEMAPHORE_CREATE_INFO"), + Self::EVENT_CREATE_INFO => Some("EVENT_CREATE_INFO"), + Self::QUERY_POOL_CREATE_INFO => Some("QUERY_POOL_CREATE_INFO"), + Self::BUFFER_CREATE_INFO => Some("BUFFER_CREATE_INFO"), + Self::BUFFER_VIEW_CREATE_INFO => Some("BUFFER_VIEW_CREATE_INFO"), + Self::IMAGE_CREATE_INFO => Some("IMAGE_CREATE_INFO"), + Self::IMAGE_VIEW_CREATE_INFO => Some("IMAGE_VIEW_CREATE_INFO"), + Self::SHADER_MODULE_CREATE_INFO => Some("SHADER_MODULE_CREATE_INFO"), + Self::PIPELINE_CACHE_CREATE_INFO => Some("PIPELINE_CACHE_CREATE_INFO"), + Self::PIPELINE_SHADER_STAGE_CREATE_INFO => Some("PIPELINE_SHADER_STAGE_CREATE_INFO"), + Self::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => { + Some("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO") + } + Self::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => { + Some("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO") + } + Self::PIPELINE_TESSELLATION_STATE_CREATE_INFO => { + Some("PIPELINE_TESSELLATION_STATE_CREATE_INFO") + } + Self::PIPELINE_VIEWPORT_STATE_CREATE_INFO => { + Some("PIPELINE_VIEWPORT_STATE_CREATE_INFO") + } + Self::PIPELINE_RASTERIZATION_STATE_CREATE_INFO => { + Some("PIPELINE_RASTERIZATION_STATE_CREATE_INFO") + } + Self::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => { + Some("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO") + } + Self::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => { + Some("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO") + } + Self::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => { + Some("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO") + } + Self::PIPELINE_DYNAMIC_STATE_CREATE_INFO => Some("PIPELINE_DYNAMIC_STATE_CREATE_INFO"), + Self::GRAPHICS_PIPELINE_CREATE_INFO => Some("GRAPHICS_PIPELINE_CREATE_INFO"), + Self::COMPUTE_PIPELINE_CREATE_INFO => Some("COMPUTE_PIPELINE_CREATE_INFO"), + Self::PIPELINE_LAYOUT_CREATE_INFO => Some("PIPELINE_LAYOUT_CREATE_INFO"), + Self::SAMPLER_CREATE_INFO => Some("SAMPLER_CREATE_INFO"), + Self::DESCRIPTOR_SET_LAYOUT_CREATE_INFO => Some("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"), + Self::DESCRIPTOR_POOL_CREATE_INFO => Some("DESCRIPTOR_POOL_CREATE_INFO"), + Self::DESCRIPTOR_SET_ALLOCATE_INFO => Some("DESCRIPTOR_SET_ALLOCATE_INFO"), + Self::WRITE_DESCRIPTOR_SET => Some("WRITE_DESCRIPTOR_SET"), + Self::COPY_DESCRIPTOR_SET => Some("COPY_DESCRIPTOR_SET"), + Self::FRAMEBUFFER_CREATE_INFO => Some("FRAMEBUFFER_CREATE_INFO"), + Self::RENDER_PASS_CREATE_INFO => Some("RENDER_PASS_CREATE_INFO"), + Self::COMMAND_POOL_CREATE_INFO => Some("COMMAND_POOL_CREATE_INFO"), + Self::COMMAND_BUFFER_ALLOCATE_INFO => Some("COMMAND_BUFFER_ALLOCATE_INFO"), + Self::COMMAND_BUFFER_INHERITANCE_INFO => Some("COMMAND_BUFFER_INHERITANCE_INFO"), + Self::COMMAND_BUFFER_BEGIN_INFO => Some("COMMAND_BUFFER_BEGIN_INFO"), + Self::RENDER_PASS_BEGIN_INFO => Some("RENDER_PASS_BEGIN_INFO"), + Self::BUFFER_MEMORY_BARRIER => Some("BUFFER_MEMORY_BARRIER"), + Self::IMAGE_MEMORY_BARRIER => Some("IMAGE_MEMORY_BARRIER"), + Self::MEMORY_BARRIER => Some("MEMORY_BARRIER"), + Self::LOADER_INSTANCE_CREATE_INFO => Some("LOADER_INSTANCE_CREATE_INFO"), + Self::LOADER_DEVICE_CREATE_INFO => Some("LOADER_DEVICE_CREATE_INFO"), + Self::SWAPCHAIN_CREATE_INFO_KHR => Some("SWAPCHAIN_CREATE_INFO_KHR"), + Self::PRESENT_INFO_KHR => Some("PRESENT_INFO_KHR"), + Self::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR => { + Some("DEVICE_GROUP_PRESENT_CAPABILITIES_KHR") + } + Self::IMAGE_SWAPCHAIN_CREATE_INFO_KHR => Some("IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), + Self::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR => { + Some("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR") + } + Self::ACQUIRE_NEXT_IMAGE_INFO_KHR => Some("ACQUIRE_NEXT_IMAGE_INFO_KHR"), + Self::DEVICE_GROUP_PRESENT_INFO_KHR => Some("DEVICE_GROUP_PRESENT_INFO_KHR"), + Self::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR => { + Some("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR") + } + Self::DISPLAY_MODE_CREATE_INFO_KHR => Some("DISPLAY_MODE_CREATE_INFO_KHR"), + Self::DISPLAY_SURFACE_CREATE_INFO_KHR => Some("DISPLAY_SURFACE_CREATE_INFO_KHR"), + Self::DISPLAY_PRESENT_INFO_KHR => Some("DISPLAY_PRESENT_INFO_KHR"), + Self::XLIB_SURFACE_CREATE_INFO_KHR => Some("XLIB_SURFACE_CREATE_INFO_KHR"), + Self::XCB_SURFACE_CREATE_INFO_KHR => Some("XCB_SURFACE_CREATE_INFO_KHR"), + Self::WAYLAND_SURFACE_CREATE_INFO_KHR => Some("WAYLAND_SURFACE_CREATE_INFO_KHR"), + Self::ANDROID_SURFACE_CREATE_INFO_KHR => Some("ANDROID_SURFACE_CREATE_INFO_KHR"), + Self::WIN32_SURFACE_CREATE_INFO_KHR => Some("WIN32_SURFACE_CREATE_INFO_KHR"), + Self::NATIVE_BUFFER_ANDROID => Some("NATIVE_BUFFER_ANDROID"), + Self::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID => { + Some("SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID") + } + Self::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID => { + Some("PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID") + } + Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT => { + Some("DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT") + } + Self::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD => { + Some("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD") + } + Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => Some("DEBUG_MARKER_OBJECT_NAME_INFO_EXT"), + Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => Some("DEBUG_MARKER_OBJECT_TAG_INFO_EXT"), + Self::DEBUG_MARKER_MARKER_INFO_EXT => Some("DEBUG_MARKER_MARKER_INFO_EXT"), + Self::VIDEO_PROFILE_INFO_KHR => Some("VIDEO_PROFILE_INFO_KHR"), + Self::VIDEO_CAPABILITIES_KHR => Some("VIDEO_CAPABILITIES_KHR"), + Self::VIDEO_PICTURE_RESOURCE_INFO_KHR => Some("VIDEO_PICTURE_RESOURCE_INFO_KHR"), + Self::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR => { + Some("VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR") + } + Self::BIND_VIDEO_SESSION_MEMORY_INFO_KHR => Some("BIND_VIDEO_SESSION_MEMORY_INFO_KHR"), + Self::VIDEO_SESSION_CREATE_INFO_KHR => Some("VIDEO_SESSION_CREATE_INFO_KHR"), + Self::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR => { + Some("VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR") + } + Self::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR => { + Some("VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR") + } + Self::VIDEO_BEGIN_CODING_INFO_KHR => Some("VIDEO_BEGIN_CODING_INFO_KHR"), + Self::VIDEO_END_CODING_INFO_KHR => Some("VIDEO_END_CODING_INFO_KHR"), + Self::VIDEO_CODING_CONTROL_INFO_KHR => Some("VIDEO_CODING_CONTROL_INFO_KHR"), + Self::VIDEO_REFERENCE_SLOT_INFO_KHR => Some("VIDEO_REFERENCE_SLOT_INFO_KHR"), + Self::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR => Some("QUEUE_FAMILY_VIDEO_PROPERTIES_KHR"), + Self::VIDEO_PROFILE_LIST_INFO_KHR => Some("VIDEO_PROFILE_LIST_INFO_KHR"), + Self::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR => { + Some("PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR") + } + Self::VIDEO_FORMAT_PROPERTIES_KHR => Some("VIDEO_FORMAT_PROPERTIES_KHR"), + Self::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR => { + Some("QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR") + } + Self::VIDEO_DECODE_INFO_KHR => Some("VIDEO_DECODE_INFO_KHR"), + Self::VIDEO_DECODE_CAPABILITIES_KHR => Some("VIDEO_DECODE_CAPABILITIES_KHR"), + Self::VIDEO_DECODE_USAGE_INFO_KHR => Some("VIDEO_DECODE_USAGE_INFO_KHR"), + Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV") + } + Self::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV") + } + Self::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT") + } + Self::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT") + } + Self::CU_MODULE_CREATE_INFO_NVX => Some("CU_MODULE_CREATE_INFO_NVX"), + Self::CU_FUNCTION_CREATE_INFO_NVX => Some("CU_FUNCTION_CREATE_INFO_NVX"), + Self::CU_LAUNCH_INFO_NVX => Some("CU_LAUNCH_INFO_NVX"), + Self::IMAGE_VIEW_HANDLE_INFO_NVX => Some("IMAGE_VIEW_HANDLE_INFO_NVX"), + Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => Some("IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"), + Self::VIDEO_ENCODE_H264_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H264_CAPABILITIES_EXT"), + Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => { + Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => { + Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT => { + Some("VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT => { + Some("VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT => { + Some("VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT => { + Some("VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H264_PROFILE_INFO_EXT"), + Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => { + Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => { + Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT => { + Some("VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"), + Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => { + Some("VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => { + Some("VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT => { + Some("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT => { + Some("VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H265_PROFILE_INFO_EXT"), + Self::VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT => { + Some("VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => { + Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => { + Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT") + } + Self::VIDEO_DECODE_H264_CAPABILITIES_KHR => Some("VIDEO_DECODE_H264_CAPABILITIES_KHR"), + Self::VIDEO_DECODE_H264_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H264_PICTURE_INFO_KHR"), + Self::VIDEO_DECODE_H264_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H264_PROFILE_INFO_KHR"), + Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR => { + Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR") + } + Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR => { + Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR") + } + Self::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR => { + Some("VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR") + } + Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => { + Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD") + } + Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => { + Some("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR") + } + Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT => { + Some("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT") + } + Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD => Some("ATTACHMENT_SAMPLE_COUNT_INFO_AMD"), + Self::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX => { + Some("MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX") + } + Self::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP => { + Some("STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP") + } + Self::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV => { + Some("PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV") + } + Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV => { + Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV") + } + Self::EXPORT_MEMORY_ALLOCATE_INFO_NV => Some("EXPORT_MEMORY_ALLOCATE_INFO_NV"), + Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"), + Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"), + Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV => { + Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV") + } + Self::VALIDATION_FLAGS_EXT => Some("VALIDATION_FLAGS_EXT"), + Self::VI_SURFACE_CREATE_INFO_NN => Some("VI_SURFACE_CREATE_INFO_NN"), + Self::IMAGE_VIEW_ASTC_DECODE_MODE_EXT => Some("IMAGE_VIEW_ASTC_DECODE_MODE_EXT"), + Self::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT") + } + Self::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT => { + Some("PIPELINE_ROBUSTNESS_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT") + } + Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { + Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR") + } + Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { + Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR") + } + Self::MEMORY_WIN32_HANDLE_PROPERTIES_KHR => Some("MEMORY_WIN32_HANDLE_PROPERTIES_KHR"), + Self::MEMORY_GET_WIN32_HANDLE_INFO_KHR => Some("MEMORY_GET_WIN32_HANDLE_INFO_KHR"), + Self::IMPORT_MEMORY_FD_INFO_KHR => Some("IMPORT_MEMORY_FD_INFO_KHR"), + Self::MEMORY_FD_PROPERTIES_KHR => Some("MEMORY_FD_PROPERTIES_KHR"), + Self::MEMORY_GET_FD_INFO_KHR => Some("MEMORY_GET_FD_INFO_KHR"), + Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR => { + Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR") + } + Self::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { + Some("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") + } + Self::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { + Some("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") + } + Self::D3D12_FENCE_SUBMIT_INFO_KHR => Some("D3D12_FENCE_SUBMIT_INFO_KHR"), + Self::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR => { + Some("SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR") + } + Self::IMPORT_SEMAPHORE_FD_INFO_KHR => Some("IMPORT_SEMAPHORE_FD_INFO_KHR"), + Self::SEMAPHORE_GET_FD_INFO_KHR => Some("SEMAPHORE_GET_FD_INFO_KHR"), + Self::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR") + } + Self::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT => { + Some("COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT") + } + Self::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT") + } + Self::CONDITIONAL_RENDERING_BEGIN_INFO_EXT => { + Some("CONDITIONAL_RENDERING_BEGIN_INFO_EXT") + } + Self::PRESENT_REGIONS_KHR => Some("PRESENT_REGIONS_KHR"), + Self::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV") + } + Self::SURFACE_CAPABILITIES_2_EXT => Some("SURFACE_CAPABILITIES_2_EXT"), + Self::DISPLAY_POWER_INFO_EXT => Some("DISPLAY_POWER_INFO_EXT"), + Self::DEVICE_EVENT_INFO_EXT => Some("DEVICE_EVENT_INFO_EXT"), + Self::DISPLAY_EVENT_INFO_EXT => Some("DISPLAY_EVENT_INFO_EXT"), + Self::SWAPCHAIN_COUNTER_CREATE_INFO_EXT => Some("SWAPCHAIN_COUNTER_CREATE_INFO_EXT"), + Self::PRESENT_TIMES_INFO_GOOGLE => Some("PRESENT_TIMES_INFO_GOOGLE"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX") + } + Self::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT") + } + Self::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT") + } + Self::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT") + } + Self::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT") + } + Self::HDR_METADATA_EXT => Some("HDR_METADATA_EXT"), + Self::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR => { + Some("SHARED_PRESENT_SURFACE_CAPABILITIES_KHR") + } + Self::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"), + Self::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"), + Self::FENCE_GET_WIN32_HANDLE_INFO_KHR => Some("FENCE_GET_WIN32_HANDLE_INFO_KHR"), + Self::IMPORT_FENCE_FD_INFO_KHR => Some("IMPORT_FENCE_FD_INFO_KHR"), + Self::FENCE_GET_FD_INFO_KHR => Some("FENCE_GET_FD_INFO_KHR"), + Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR") + } + Self::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR => { + Some("QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR") + } + Self::PERFORMANCE_QUERY_SUBMIT_INFO_KHR => Some("PERFORMANCE_QUERY_SUBMIT_INFO_KHR"), + Self::ACQUIRE_PROFILING_LOCK_INFO_KHR => Some("ACQUIRE_PROFILING_LOCK_INFO_KHR"), + Self::PERFORMANCE_COUNTER_KHR => Some("PERFORMANCE_COUNTER_KHR"), + Self::PERFORMANCE_COUNTER_DESCRIPTION_KHR => { + Some("PERFORMANCE_COUNTER_DESCRIPTION_KHR") + } + Self::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR => Some("PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"), + Self::SURFACE_CAPABILITIES_2_KHR => Some("SURFACE_CAPABILITIES_2_KHR"), + Self::SURFACE_FORMAT_2_KHR => Some("SURFACE_FORMAT_2_KHR"), + Self::DISPLAY_PROPERTIES_2_KHR => Some("DISPLAY_PROPERTIES_2_KHR"), + Self::DISPLAY_PLANE_PROPERTIES_2_KHR => Some("DISPLAY_PLANE_PROPERTIES_2_KHR"), + Self::DISPLAY_MODE_PROPERTIES_2_KHR => Some("DISPLAY_MODE_PROPERTIES_2_KHR"), + Self::DISPLAY_PLANE_INFO_2_KHR => Some("DISPLAY_PLANE_INFO_2_KHR"), + Self::DISPLAY_PLANE_CAPABILITIES_2_KHR => Some("DISPLAY_PLANE_CAPABILITIES_2_KHR"), + Self::IOS_SURFACE_CREATE_INFO_MVK => Some("IOS_SURFACE_CREATE_INFO_MVK"), + Self::MACOS_SURFACE_CREATE_INFO_MVK => Some("MACOS_SURFACE_CREATE_INFO_MVK"), + Self::DEBUG_UTILS_OBJECT_NAME_INFO_EXT => Some("DEBUG_UTILS_OBJECT_NAME_INFO_EXT"), + Self::DEBUG_UTILS_OBJECT_TAG_INFO_EXT => Some("DEBUG_UTILS_OBJECT_TAG_INFO_EXT"), + Self::DEBUG_UTILS_LABEL_EXT => Some("DEBUG_UTILS_LABEL_EXT"), + Self::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT => { + Some("DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT") + } + Self::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT => { + Some("DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT") + } + Self::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_USAGE_ANDROID") + } + Self::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID") + } + Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID") + } + Self::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { + Some("IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") + } + Self::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { + Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") + } + Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"), + Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID") + } + Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"), + Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => { + Some("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT") + } + Self::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT") + } + Self::MULTISAMPLE_PROPERTIES_EXT => Some("MULTISAMPLE_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT") + } + Self::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT") + } + Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => { + Some("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV") + } + Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR => { + Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR") + } + Self::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR") + } + Self::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_KHR") + } + Self::ACCELERATION_STRUCTURE_VERSION_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_VERSION_INFO_KHR") + } + Self::COPY_ACCELERATION_STRUCTURE_INFO_KHR => { + Some("COPY_ACCELERATION_STRUCTURE_INFO_KHR") + } + Self::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR => { + Some("COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR") + } + Self::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR => { + Some("COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR") + } + Self::ACCELERATION_STRUCTURE_CREATE_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_CREATE_INFO_KHR") + } + Self::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR") + } + Self::RAY_TRACING_PIPELINE_CREATE_INFO_KHR => { + Some("RAY_TRACING_PIPELINE_CREATE_INFO_KHR") + } + Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR => { + Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR") + } + Self::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR => { + Some("RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR") + } + Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => { + Some("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV => { + Some("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV") + } + Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT => { + Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT") + } + Self::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT") + } + Self::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT => { + Some("IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT") + } + Self::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT => { + Some("IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT") + } + Self::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT => { + Some("IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT") + } + Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT => { + Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT") + } + Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"), + Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => { + Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR") + } + Self::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV => { + Some("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV") + } + Self::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV") + } + Self::RAY_TRACING_PIPELINE_CREATE_INFO_NV => { + Some("RAY_TRACING_PIPELINE_CREATE_INFO_NV") + } + Self::ACCELERATION_STRUCTURE_CREATE_INFO_NV => { + Some("ACCELERATION_STRUCTURE_CREATE_INFO_NV") + } + Self::GEOMETRY_NV => Some("GEOMETRY_NV"), + Self::GEOMETRY_TRIANGLES_NV => Some("GEOMETRY_TRIANGLES_NV"), + Self::GEOMETRY_AABB_NV => Some("GEOMETRY_AABB_NV"), + Self::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV => { + Some("BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV") + } + Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV => { + Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV") + } + Self::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV => { + Some("ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV") + } + Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV => { + Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV") + } + Self::ACCELERATION_STRUCTURE_INFO_NV => Some("ACCELERATION_STRUCTURE_INFO_NV"), + Self::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV => { + Some("PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV") + } + Self::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV => { + Some("PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT") + } + Self::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT => { + Some("FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT") + } + Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => { + Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT") + } + Self::MEMORY_HOST_POINTER_PROPERTIES_EXT => Some("MEMORY_HOST_POINTER_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR") + } + Self::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD => { + Some("PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD") + } + Self::CALIBRATED_TIMESTAMP_INFO_EXT => Some("CALIBRATED_TIMESTAMP_INFO_EXT"), + Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => { + Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD") + } + Self::VIDEO_DECODE_H265_CAPABILITIES_KHR => Some("VIDEO_DECODE_H265_CAPABILITIES_KHR"), + Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR => { + Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR") + } + Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR => { + Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR") + } + Self::VIDEO_DECODE_H265_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H265_PROFILE_INFO_KHR"), + Self::VIDEO_DECODE_H265_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H265_PICTURE_INFO_KHR"), + Self::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR => { + Some("VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR") + } + Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR => { + Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR") + } + Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR => { + Some("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR") + } + Self::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD => { + Some("DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD") + } + Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT") + } + Self::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT") + } + Self::PRESENT_FRAME_TOKEN_GGP => Some("PRESENT_FRAME_TOKEN_GGP"), + Self::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV => { + Some("PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV => { + Some("PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV") + } + Self::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV => { + Some("PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV") + } + Self::CHECKPOINT_DATA_NV => Some("CHECKPOINT_DATA_NV"), + Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV => { + Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL => { + Some("PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL") + } + Self::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL => { + Some("QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL") + } + Self::INITIALIZE_PERFORMANCE_API_INFO_INTEL => { + Some("INITIALIZE_PERFORMANCE_API_INFO_INTEL") + } + Self::PERFORMANCE_MARKER_INFO_INTEL => Some("PERFORMANCE_MARKER_INFO_INTEL"), + Self::PERFORMANCE_STREAM_MARKER_INFO_INTEL => { + Some("PERFORMANCE_STREAM_MARKER_INFO_INTEL") + } + Self::PERFORMANCE_OVERRIDE_INFO_INTEL => Some("PERFORMANCE_OVERRIDE_INFO_INTEL"), + Self::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL => { + Some("PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL") + } + Self::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT") + } + Self::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD => { + Some("DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD") + } + Self::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD => { + Some("SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD") + } + Self::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA => { + Some("IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA") + } + Self::METAL_SURFACE_CREATE_INFO_EXT => Some("METAL_SURFACE_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT") + } + Self::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT => { + Some("RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT") + } + Self::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => { + Some("FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR") + } + Self::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR => { + Some("PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR") + } + Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD => { + Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD") + } + Self::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD => { + Some("PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD") + } + Self::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT") + } + Self::MEMORY_PRIORITY_ALLOCATE_INFO_EXT => Some("MEMORY_PRIORITY_ALLOCATE_INFO_EXT"), + Self::SURFACE_PROTECTED_CAPABILITIES_KHR => Some("SURFACE_PROTECTED_CAPABILITIES_KHR"), + Self::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT") + } + Self::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT => { + Some("BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT") + } + Self::VALIDATION_FEATURES_EXT => Some("VALIDATION_FEATURES_EXT"), + Self::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV") + } + Self::COOPERATIVE_MATRIX_PROPERTIES_NV => Some("COOPERATIVE_MATRIX_PROPERTIES_NV"), + Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV") + } + Self::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV => { + Some("PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV") + } + Self::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV => { + Some("FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT") + } + Self::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT") + } + Self::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT => { + Some("SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT") + } + Self::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT => { + Some("SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT") + } + Self::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT => { + Some("SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT") + } + Self::HEADLESS_SURFACE_CREATE_INFO_EXT => Some("HEADLESS_SURFACE_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT") + } + Self::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR") + } + Self::PIPELINE_INFO_KHR => Some("PIPELINE_INFO_KHR"), + Self::PIPELINE_EXECUTABLE_PROPERTIES_KHR => Some("PIPELINE_EXECUTABLE_PROPERTIES_KHR"), + Self::PIPELINE_EXECUTABLE_INFO_KHR => Some("PIPELINE_EXECUTABLE_INFO_KHR"), + Self::PIPELINE_EXECUTABLE_STATISTIC_KHR => Some("PIPELINE_EXECUTABLE_STATISTIC_KHR"), + Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => { + Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR") + } + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT") + } + Self::SURFACE_PRESENT_MODE_EXT => Some("SURFACE_PRESENT_MODE_EXT"), + Self::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT => { + Some("SURFACE_PRESENT_SCALING_CAPABILITIES_EXT") + } + Self::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT => { + Some("SURFACE_PRESENT_MODE_COMPATIBILITY_EXT") + } + Self::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT") + } + Self::SWAPCHAIN_PRESENT_FENCE_INFO_EXT => Some("SWAPCHAIN_PRESENT_FENCE_INFO_EXT"), + Self::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT => { + Some("SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT") + } + Self::SWAPCHAIN_PRESENT_MODE_INFO_EXT => Some("SWAPCHAIN_PRESENT_MODE_INFO_EXT"), + Self::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT => { + Some("SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT") + } + Self::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT => Some("RELEASE_SWAPCHAIN_IMAGES_INFO_EXT"), + Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV") + } + Self::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV => { + Some("GRAPHICS_SHADER_GROUP_CREATE_INFO_NV") + } + Self::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV => { + Some("GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV") + } + Self::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV => Some("INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"), + Self::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV => { + Some("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV") + } + Self::GENERATED_COMMANDS_INFO_NV => Some("GENERATED_COMMANDS_INFO_NV"), + Self::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV => { + Some("GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV") + } + Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV => { + Some("PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV") + } + Self::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV => { + Some("COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV") + } + Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT") + } + Self::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM => { + Some("COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM") + } + Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => { + Some("RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT") + } + Self::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT => { + Some("DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT") + } + Self::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT => { + Some("DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT") + } + Self::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT") + } + Self::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT => { + Some("SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT") + } + Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"), + Self::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV => { + Some("PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV") + } + Self::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV => { + Some("SURFACE_CAPABILITIES_PRESENT_BARRIER_NV") + } + Self::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV => { + Some("SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV") + } + Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"), + Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR") + } + Self::VIDEO_ENCODE_INFO_KHR => Some("VIDEO_ENCODE_INFO_KHR"), + Self::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR => Some("VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"), + Self::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR => { + Some("VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR") + } + Self::VIDEO_ENCODE_CAPABILITIES_KHR => Some("VIDEO_ENCODE_CAPABILITIES_KHR"), + Self::VIDEO_ENCODE_USAGE_INFO_KHR => Some("VIDEO_ENCODE_USAGE_INFO_KHR"), + Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV") + } + Self::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV => { + Some("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV") + } + Self::RESERVED_QCOM => Some("RESERVED_QCOM"), + Self::EXPORT_METAL_OBJECT_CREATE_INFO_EXT => { + Some("EXPORT_METAL_OBJECT_CREATE_INFO_EXT") + } + Self::EXPORT_METAL_OBJECTS_INFO_EXT => Some("EXPORT_METAL_OBJECTS_INFO_EXT"), + Self::EXPORT_METAL_DEVICE_INFO_EXT => Some("EXPORT_METAL_DEVICE_INFO_EXT"), + Self::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT => { + Some("EXPORT_METAL_COMMAND_QUEUE_INFO_EXT") + } + Self::EXPORT_METAL_BUFFER_INFO_EXT => Some("EXPORT_METAL_BUFFER_INFO_EXT"), + Self::IMPORT_METAL_BUFFER_INFO_EXT => Some("IMPORT_METAL_BUFFER_INFO_EXT"), + Self::EXPORT_METAL_TEXTURE_INFO_EXT => Some("EXPORT_METAL_TEXTURE_INFO_EXT"), + Self::IMPORT_METAL_TEXTURE_INFO_EXT => Some("IMPORT_METAL_TEXTURE_INFO_EXT"), + Self::EXPORT_METAL_IO_SURFACE_INFO_EXT => Some("EXPORT_METAL_IO_SURFACE_INFO_EXT"), + Self::IMPORT_METAL_IO_SURFACE_INFO_EXT => Some("IMPORT_METAL_IO_SURFACE_INFO_EXT"), + Self::EXPORT_METAL_SHARED_EVENT_INFO_EXT => Some("EXPORT_METAL_SHARED_EVENT_INFO_EXT"), + Self::IMPORT_METAL_SHARED_EVENT_INFO_EXT => Some("IMPORT_METAL_SHARED_EVENT_INFO_EXT"), + Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV => { + Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV") + } + Self::CHECKPOINT_DATA_2_NV => Some("CHECKPOINT_DATA_2_NV"), + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT") + } + Self::DESCRIPTOR_ADDRESS_INFO_EXT => Some("DESCRIPTOR_ADDRESS_INFO_EXT"), + Self::DESCRIPTOR_GET_INFO_EXT => Some("DESCRIPTOR_GET_INFO_EXT"), + Self::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT => { + Some("OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT") + } + Self::DESCRIPTOR_BUFFER_BINDING_INFO_EXT => Some("DESCRIPTOR_BUFFER_BINDING_INFO_EXT"), + Self::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT => { + Some("DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT") + } + Self::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT") + } + Self::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT => { + Some("GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD => { + Some("PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR") + } + Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV") + } + Self::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV => { + Some("PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV") + } + Self::ACCELERATION_STRUCTURE_MOTION_INFO_NV => { + Some("ACCELERATION_STRUCTURE_MOTION_INFO_NV") + } + Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT") + } + Self::COPY_COMMAND_TRANSFORM_INFO_QCOM => Some("COPY_COMMAND_TRANSFORM_INFO_QCOM"), + Self::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT") + } + Self::IMAGE_COMPRESSION_CONTROL_EXT => Some("IMAGE_COMPRESSION_CONTROL_EXT"), + Self::SUBRESOURCE_LAYOUT_2_EXT => Some("SUBRESOURCE_LAYOUT_2_EXT"), + Self::IMAGE_SUBRESOURCE_2_EXT => Some("IMAGE_SUBRESOURCE_2_EXT"), + Self::IMAGE_COMPRESSION_PROPERTIES_EXT => Some("IMAGE_COMPRESSION_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FAULT_FEATURES_EXT => Some("PHYSICAL_DEVICE_FAULT_FEATURES_EXT"), + Self::DEVICE_FAULT_COUNTS_EXT => Some("DEVICE_FAULT_COUNTS_EXT"), + Self::DEVICE_FAULT_INFO_EXT => Some("DEVICE_FAULT_INFO_EXT"), + Self::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT") + } + Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT") + } + Self::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT => { + Some("VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT") + } + Self::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT => { + Some("VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT") + } + Self::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT => Some("PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT") + } + Self::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT => { + Some("DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT") + } + Self::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT") + } + Self::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT => { + Some("PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT") + } + Self::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA => { + Some("IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA") + } + Self::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA => { + Some("MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA") + } + Self::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA => { + Some("MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA") + } + Self::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA => { + Some("IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA") + } + Self::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA => { + Some("SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA") + } + Self::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_CREATE_INFO_FUCHSIA") + } + Self::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA => { + Some("IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA") + } + Self::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA") + } + Self::BUFFER_COLLECTION_PROPERTIES_FUCHSIA => { + Some("BUFFER_COLLECTION_PROPERTIES_FUCHSIA") + } + Self::BUFFER_CONSTRAINTS_INFO_FUCHSIA => Some("BUFFER_CONSTRAINTS_INFO_FUCHSIA"), + Self::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA") + } + Self::IMAGE_CONSTRAINTS_INFO_FUCHSIA => Some("IMAGE_CONSTRAINTS_INFO_FUCHSIA"), + Self::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA => { + Some("IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA") + } + Self::SYSMEM_COLOR_SPACE_FUCHSIA => Some("SYSMEM_COLOR_SPACE_FUCHSIA"), + Self::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA") + } + Self::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI => { + Some("SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI") + } + Self::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI => { + Some("PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI") + } + Self::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI => { + Some("PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI") + } + Self::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI => { + Some("PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI") + } + Self::MEMORY_GET_REMOTE_ADDRESS_INFO_NV => Some("MEMORY_GET_REMOTE_ADDRESS_INFO_NV"), + Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => { + Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV") + } + Self::PIPELINE_PROPERTIES_IDENTIFIER_EXT => Some("PIPELINE_PROPERTIES_IDENTIFIER_EXT"), + Self::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT") + } + Self::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT => { + Some("SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT") + } + Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT => { + Some("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT") + } + Self::SCREEN_SURFACE_CREATE_INFO_QNX => Some("SCREEN_SURFACE_CREATE_INFO_QNX"), + Self::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT") + } + Self::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT => { + Some("PIPELINE_COLOR_WRITE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT") + } + Self::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT => Some("IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT") + } + Self::MICROMAP_BUILD_INFO_EXT => Some("MICROMAP_BUILD_INFO_EXT"), + Self::MICROMAP_VERSION_INFO_EXT => Some("MICROMAP_VERSION_INFO_EXT"), + Self::COPY_MICROMAP_INFO_EXT => Some("COPY_MICROMAP_INFO_EXT"), + Self::COPY_MICROMAP_TO_MEMORY_INFO_EXT => Some("COPY_MICROMAP_TO_MEMORY_INFO_EXT"), + Self::COPY_MEMORY_TO_MICROMAP_INFO_EXT => Some("COPY_MEMORY_TO_MICROMAP_INFO_EXT"), + Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT") + } + Self::MICROMAP_CREATE_INFO_EXT => Some("MICROMAP_CREATE_INFO_EXT"), + Self::MICROMAP_BUILD_SIZES_INFO_EXT => Some("MICROMAP_BUILD_SIZES_INFO_EXT"), + Self::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT => { + Some("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT") + } + Self::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT") + } + Self::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT => { + Some("SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE") + } + Self::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE => { + Some("DESCRIPTOR_SET_BINDING_REFERENCE_VALVE") + } + Self::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE => { + Some("DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE") + } + Self::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM") + } + Self::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM => { + Some("SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV => { + Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => { + Some("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM => { + Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM") + } + Self::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM => { + Some("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT") + } + Self::RENDER_PASS_CREATION_CONTROL_EXT => Some("RENDER_PASS_CREATION_CONTROL_EXT"), + Self::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT => { + Some("RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT") + } + Self::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT => { + Some("RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT") + } + Self::DIRECT_DRIVER_LOADING_INFO_LUNARG => Some("DIRECT_DRIVER_LOADING_INFO_LUNARG"), + Self::DIRECT_DRIVER_LOADING_LIST_LUNARG => Some("DIRECT_DRIVER_LOADING_LIST_LUNARG"), + Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT") + } + Self::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT => { + Some("PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT") + } + Self::SHADER_MODULE_IDENTIFIER_EXT => Some("SHADER_MODULE_IDENTIFIER_EXT"), + Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV => { + Some("PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV") + } + Self::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV => Some("OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV"), + Self::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV => { + Some("OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV") + } + Self::OPTICAL_FLOW_SESSION_CREATE_INFO_NV => { + Some("OPTICAL_FLOW_SESSION_CREATE_INFO_NV") + } + Self::OPTICAL_FLOW_EXECUTE_INFO_NV => Some("OPTICAL_FLOW_EXECUTE_INFO_NV"), + Self::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV => { + Some("OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV") + } + Self::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM") + } + Self::TILE_PROPERTIES_QCOM => Some("TILE_PROPERTIES_QCOM"), + Self::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC => { + Some("PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC") + } + Self::AMIGO_PROFILING_SUBMIT_INFO_SEC => Some("AMIGO_PROFILING_SUBMIT_INFO_SEC"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT") + } + Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT => { + Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM => { + Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM") + } + Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM => { + Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM") + } + Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { + Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") + } + Self::BIND_BUFFER_MEMORY_INFO => Some("BIND_BUFFER_MEMORY_INFO"), + Self::BIND_IMAGE_MEMORY_INFO => Some("BIND_IMAGE_MEMORY_INFO"), + Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => { + Some("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES") + } + Self::MEMORY_DEDICATED_REQUIREMENTS => Some("MEMORY_DEDICATED_REQUIREMENTS"), + Self::MEMORY_DEDICATED_ALLOCATE_INFO => Some("MEMORY_DEDICATED_ALLOCATE_INFO"), + Self::MEMORY_ALLOCATE_FLAGS_INFO => Some("MEMORY_ALLOCATE_FLAGS_INFO"), + Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => { + Some("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO") + } + Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => { + Some("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO") + } + Self::DEVICE_GROUP_SUBMIT_INFO => Some("DEVICE_GROUP_SUBMIT_INFO"), + Self::DEVICE_GROUP_BIND_SPARSE_INFO => Some("DEVICE_GROUP_BIND_SPARSE_INFO"), + Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => { + Some("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO") + } + Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => { + Some("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO") + } + Self::PHYSICAL_DEVICE_GROUP_PROPERTIES => Some("PHYSICAL_DEVICE_GROUP_PROPERTIES"), + Self::DEVICE_GROUP_DEVICE_CREATE_INFO => Some("DEVICE_GROUP_DEVICE_CREATE_INFO"), + Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2 => Some("BUFFER_MEMORY_REQUIREMENTS_INFO_2"), + Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2 => Some("IMAGE_MEMORY_REQUIREMENTS_INFO_2"), + Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => { + Some("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2") + } + Self::MEMORY_REQUIREMENTS_2 => Some("MEMORY_REQUIREMENTS_2"), + Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 => Some("SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"), + Self::PHYSICAL_DEVICE_FEATURES_2 => Some("PHYSICAL_DEVICE_FEATURES_2"), + Self::PHYSICAL_DEVICE_PROPERTIES_2 => Some("PHYSICAL_DEVICE_PROPERTIES_2"), + Self::FORMAT_PROPERTIES_2 => Some("FORMAT_PROPERTIES_2"), + Self::IMAGE_FORMAT_PROPERTIES_2 => Some("IMAGE_FORMAT_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 => { + Some("PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2") + } + Self::QUEUE_FAMILY_PROPERTIES_2 => Some("QUEUE_FAMILY_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 => { + Some("PHYSICAL_DEVICE_MEMORY_PROPERTIES_2") + } + Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2 => Some("SPARSE_IMAGE_FORMAT_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 => { + Some("PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2") + } + Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES => { + Some("PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES") + } + Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO => { + Some("RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO") + } + Self::IMAGE_VIEW_USAGE_CREATE_INFO => Some("IMAGE_VIEW_USAGE_CREATE_INFO"), + Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO => { + Some("PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO") + } + Self::RENDER_PASS_MULTIVIEW_CREATE_INFO => Some("RENDER_PASS_MULTIVIEW_CREATE_INFO"), + Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES => Some("PHYSICAL_DEVICE_MULTIVIEW_FEATURES"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES") + } + Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES => { + Some("PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES") + } + Self::PROTECTED_SUBMIT_INFO => Some("PROTECTED_SUBMIT_INFO"), + Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES => { + Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES") + } + Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES => { + Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES") + } + Self::DEVICE_QUEUE_INFO_2 => Some("DEVICE_QUEUE_INFO_2"), + Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO => { + Some("SAMPLER_YCBCR_CONVERSION_CREATE_INFO") + } + Self::SAMPLER_YCBCR_CONVERSION_INFO => Some("SAMPLER_YCBCR_CONVERSION_INFO"), + Self::BIND_IMAGE_PLANE_MEMORY_INFO => Some("BIND_IMAGE_PLANE_MEMORY_INFO"), + Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO => { + Some("IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO") + } + Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES => { + Some("PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES") + } + Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES => { + Some("SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES") + } + Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO => { + Some("DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO") + } + Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES => Some("EXTERNAL_IMAGE_FORMAT_PROPERTIES"), + Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO") + } + Self::EXTERNAL_BUFFER_PROPERTIES => Some("EXTERNAL_BUFFER_PROPERTIES"), + Self::PHYSICAL_DEVICE_ID_PROPERTIES => Some("PHYSICAL_DEVICE_ID_PROPERTIES"), + Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO => Some("EXTERNAL_MEMORY_BUFFER_CREATE_INFO"), + Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO => Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO"), + Self::EXPORT_MEMORY_ALLOCATE_INFO => Some("EXPORT_MEMORY_ALLOCATE_INFO"), + Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO") + } + Self::EXTERNAL_FENCE_PROPERTIES => Some("EXTERNAL_FENCE_PROPERTIES"), + Self::EXPORT_FENCE_CREATE_INFO => Some("EXPORT_FENCE_CREATE_INFO"), + Self::EXPORT_SEMAPHORE_CREATE_INFO => Some("EXPORT_SEMAPHORE_CREATE_INFO"), + Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO") + } + Self::EXTERNAL_SEMAPHORE_PROPERTIES => Some("EXTERNAL_SEMAPHORE_PROPERTIES"), + Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES => { + Some("PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES") + } + Self::DESCRIPTOR_SET_LAYOUT_SUPPORT => Some("DESCRIPTOR_SET_LAYOUT_SUPPORT"), + Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES => { + Some("PHYSICAL_DEVICE_VULKAN_1_1_FEATURES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES => { + Some("PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES => { + Some("PHYSICAL_DEVICE_VULKAN_1_2_FEATURES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES => { + Some("PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES") + } + Self::IMAGE_FORMAT_LIST_CREATE_INFO => Some("IMAGE_FORMAT_LIST_CREATE_INFO"), + Self::ATTACHMENT_DESCRIPTION_2 => Some("ATTACHMENT_DESCRIPTION_2"), + Self::ATTACHMENT_REFERENCE_2 => Some("ATTACHMENT_REFERENCE_2"), + Self::SUBPASS_DESCRIPTION_2 => Some("SUBPASS_DESCRIPTION_2"), + Self::SUBPASS_DEPENDENCY_2 => Some("SUBPASS_DEPENDENCY_2"), + Self::RENDER_PASS_CREATE_INFO_2 => Some("RENDER_PASS_CREATE_INFO_2"), + Self::SUBPASS_BEGIN_INFO => Some("SUBPASS_BEGIN_INFO"), + Self::SUBPASS_END_INFO => Some("SUBPASS_END_INFO"), + Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES => { + Some("PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES") + } + Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES => Some("PHYSICAL_DEVICE_DRIVER_PROPERTIES"), + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES") + } + Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES") + } + Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES => { + Some("PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES") + } + Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO => { + Some("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES") + } + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO => { + Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO") + } + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT => { + Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT") + } + Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES => { + Some("PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES") + } + Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE => { + Some("SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE") + } + Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES => { + Some("PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES") + } + Self::IMAGE_STENCIL_USAGE_CREATE_INFO => Some("IMAGE_STENCIL_USAGE_CREATE_INFO"), + Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES => { + Some("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES") + } + Self::SAMPLER_REDUCTION_MODE_CREATE_INFO => Some("SAMPLER_REDUCTION_MODE_CREATE_INFO"), + Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES => { + Some("PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES") + } + Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES => { + Some("PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES") + } + Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO => { + Some("FRAMEBUFFER_ATTACHMENTS_CREATE_INFO") + } + Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO => Some("FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"), + Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO => Some("RENDER_PASS_ATTACHMENT_BEGIN_INFO"), + Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES => { + Some("PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES") + } + Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES") + } + Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES => { + Some("PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES") + } + Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT => { + Some("ATTACHMENT_REFERENCE_STENCIL_LAYOUT") + } + Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT => { + Some("ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT") + } + Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES => { + Some("PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES") + } + Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES => { + Some("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES") + } + Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES => { + Some("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES") + } + Self::SEMAPHORE_TYPE_CREATE_INFO => Some("SEMAPHORE_TYPE_CREATE_INFO"), + Self::TIMELINE_SEMAPHORE_SUBMIT_INFO => Some("TIMELINE_SEMAPHORE_SUBMIT_INFO"), + Self::SEMAPHORE_WAIT_INFO => Some("SEMAPHORE_WAIT_INFO"), + Self::SEMAPHORE_SIGNAL_INFO => Some("SEMAPHORE_SIGNAL_INFO"), + Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES => { + Some("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES") + } + Self::BUFFER_DEVICE_ADDRESS_INFO => Some("BUFFER_DEVICE_ADDRESS_INFO"), + Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO => { + Some("BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO") + } + Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO => { + Some("MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO") + } + Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO => { + Some("DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO") + } + Self::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES => { + Some("PHYSICAL_DEVICE_VULKAN_1_3_FEATURES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES => { + Some("PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES") + } + Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO => { + Some("PIPELINE_CREATION_FEEDBACK_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES") + } + Self::PHYSICAL_DEVICE_TOOL_PROPERTIES => Some("PHYSICAL_DEVICE_TOOL_PROPERTIES"), + Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES") + } + Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES => { + Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES") + } + Self::DEVICE_PRIVATE_DATA_CREATE_INFO => Some("DEVICE_PRIVATE_DATA_CREATE_INFO"), + Self::PRIVATE_DATA_SLOT_CREATE_INFO => Some("PRIVATE_DATA_SLOT_CREATE_INFO"), + Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES => { + Some("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES") + } + Self::MEMORY_BARRIER_2 => Some("MEMORY_BARRIER_2"), + Self::BUFFER_MEMORY_BARRIER_2 => Some("BUFFER_MEMORY_BARRIER_2"), + Self::IMAGE_MEMORY_BARRIER_2 => Some("IMAGE_MEMORY_BARRIER_2"), + Self::DEPENDENCY_INFO => Some("DEPENDENCY_INFO"), + Self::SUBMIT_INFO_2 => Some("SUBMIT_INFO_2"), + Self::SEMAPHORE_SUBMIT_INFO => Some("SEMAPHORE_SUBMIT_INFO"), + Self::COMMAND_BUFFER_SUBMIT_INFO => Some("COMMAND_BUFFER_SUBMIT_INFO"), + Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES => { + Some("PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES") + } + Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES => { + Some("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES") + } + Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES => { + Some("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES") + } + Self::COPY_BUFFER_INFO_2 => Some("COPY_BUFFER_INFO_2"), + Self::COPY_IMAGE_INFO_2 => Some("COPY_IMAGE_INFO_2"), + Self::COPY_BUFFER_TO_IMAGE_INFO_2 => Some("COPY_BUFFER_TO_IMAGE_INFO_2"), + Self::COPY_IMAGE_TO_BUFFER_INFO_2 => Some("COPY_IMAGE_TO_BUFFER_INFO_2"), + Self::BLIT_IMAGE_INFO_2 => Some("BLIT_IMAGE_INFO_2"), + Self::RESOLVE_IMAGE_INFO_2 => Some("RESOLVE_IMAGE_INFO_2"), + Self::BUFFER_COPY_2 => Some("BUFFER_COPY_2"), + Self::IMAGE_COPY_2 => Some("IMAGE_COPY_2"), + Self::IMAGE_BLIT_2 => Some("IMAGE_BLIT_2"), + Self::BUFFER_IMAGE_COPY_2 => Some("BUFFER_IMAGE_COPY_2"), + Self::IMAGE_RESOLVE_2 => Some("IMAGE_RESOLVE_2"), + Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES => { + Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES") + } + Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO => { + Some("PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES => { + Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES") + } + Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES => { + Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES") + } + Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES => { + Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES") + } + Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK => { + Some("WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK") + } + Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO => { + Some("DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES => { + Some("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES") + } + Self::RENDERING_INFO => Some("RENDERING_INFO"), + Self::RENDERING_ATTACHMENT_INFO => Some("RENDERING_ATTACHMENT_INFO"), + Self::PIPELINE_RENDERING_CREATE_INFO => Some("PIPELINE_RENDERING_CREATE_INFO"), + Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES => { + Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES") + } + Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO => { + Some("COMMAND_BUFFER_INHERITANCE_RENDERING_INFO") + } + Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES") + } + Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES => { + Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES") + } + Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES => { + Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES") + } + Self::FORMAT_PROPERTIES_3 => Some("FORMAT_PROPERTIES_3"), + Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES => { + Some("PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES") + } + Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES => { + Some("PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES") + } + Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS => Some("DEVICE_BUFFER_MEMORY_REQUIREMENTS"), + Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS => Some("DEVICE_IMAGE_MEMORY_REQUIREMENTS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SubmitFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SubmitFlags::PROTECTED.0, "PROTECTED")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ( + SubpassDescriptionFlags::FRAGMENT_REGION_QCOM.0, + "FRAGMENT_REGION_QCOM", + ), + ( + SubpassDescriptionFlags::SHADER_RESOLVE_QCOM.0, + "SHADER_RESOLVE_QCOM", + ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT.0, + "RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT", + ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT.0, + "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT", + ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT.0, + "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT", + ), + ( + SubpassDescriptionFlags::ENABLE_LEGACY_DITHERING_EXT.0, + "ENABLE_LEGACY_DITHERING_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SubpassMergeStatusEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::MERGED => Some("MERGED"), + Self::DISALLOWED => Some("DISALLOWED"), + Self::NOT_MERGED_SIDE_EFFECTS => Some("NOT_MERGED_SIDE_EFFECTS"), + Self::NOT_MERGED_SAMPLES_MISMATCH => Some("NOT_MERGED_SAMPLES_MISMATCH"), + Self::NOT_MERGED_VIEWS_MISMATCH => Some("NOT_MERGED_VIEWS_MISMATCH"), + Self::NOT_MERGED_ALIASING => Some("NOT_MERGED_ALIASING"), + Self::NOT_MERGED_DEPENDENCIES => Some("NOT_MERGED_DEPENDENCIES"), + Self::NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT => { + Some("NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT") + } + Self::NOT_MERGED_TOO_MANY_ATTACHMENTS => Some("NOT_MERGED_TOO_MANY_ATTACHMENTS"), + Self::NOT_MERGED_INSUFFICIENT_STORAGE => Some("NOT_MERGED_INSUFFICIENT_STORAGE"), + Self::NOT_MERGED_DEPTH_STENCIL_COUNT => Some("NOT_MERGED_DEPTH_STENCIL_COUNT"), + Self::NOT_MERGED_RESOLVE_ATTACHMENT_REUSE => { + Some("NOT_MERGED_RESOLVE_ATTACHMENT_REUSE") + } + Self::NOT_MERGED_SINGLE_SUBPASS => Some("NOT_MERGED_SINGLE_SUBPASS"), + Self::NOT_MERGED_UNSPECIFIED => Some("NOT_MERGED_UNSPECIFIED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + ( + SwapchainCreateFlagsKHR::DEFERRED_MEMORY_ALLOCATION_EXT.0, + "DEFERRED_MEMORY_ALLOCATION_EXT", + ), + (SwapchainCreateFlagsKHR::RESERVED_4_EXT.0, "RESERVED_4_EXT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SwapchainImageUsageFlagsANDROID { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SwapchainImageUsageFlagsANDROID::SHARED.0, "SHARED")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for TimeDomainEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ToolPurposeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ToolPurposeFlags::VALIDATION.0, "VALIDATION"), + (ToolPurposeFlags::PROFILING.0, "PROFILING"), + (ToolPurposeFlags::TRACING.0, "TRACING"), + ( + ToolPurposeFlags::ADDITIONAL_FEATURES.0, + "ADDITIONAL_FEATURES", + ), + (ToolPurposeFlags::MODIFYING_FEATURES.0, "MODIFYING_FEATURES"), + ( + ToolPurposeFlags::DEBUG_REPORTING_EXT.0, + "DEBUG_REPORTING_EXT", + ), + (ToolPurposeFlags::DEBUG_MARKERS_EXT.0, "DEBUG_MARKERS_EXT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ValidationCacheCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ValidationFeatureDisableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + Self::THREAD_SAFETY => Some("THREAD_SAFETY"), + Self::API_PARAMETERS => Some("API_PARAMETERS"), + Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), + Self::CORE_CHECKS => Some("CORE_CHECKS"), + Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + Self::SHADER_VALIDATION_CACHE => Some("SHADER_VALIDATION_CACHE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ValidationFeatureEnableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), + Self::BEST_PRACTICES => Some("BEST_PRACTICES"), + Self::DEBUG_PRINTF => Some("DEBUG_PRINTF"), + Self::SYNCHRONIZATION_VALIDATION => Some("SYNCHRONIZATION_VALIDATION"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + Self::CODEPLAY => Some("CODEPLAY"), + Self::MESA => Some("MESA"), + Self::POCL => Some("POCL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ViSurfaceCreateFlagsNN { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoBeginCodingFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoCapabilityFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoCapabilityFlagsKHR::PROTECTED_CONTENT.0, + "PROTECTED_CONTENT", + ), + ( + VideoCapabilityFlagsKHR::SEPARATE_REFERENCE_IMAGES.0, + "SEPARATE_REFERENCE_IMAGES", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoChromaSubsamplingFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoChromaSubsamplingFlagsKHR::INVALID.0, "INVALID"), + (VideoChromaSubsamplingFlagsKHR::MONOCHROME.0, "MONOCHROME"), + (VideoChromaSubsamplingFlagsKHR::TYPE_420.0, "TYPE_420"), + (VideoChromaSubsamplingFlagsKHR::TYPE_422.0, "TYPE_422"), + (VideoChromaSubsamplingFlagsKHR::TYPE_444.0, "TYPE_444"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoCodecOperationFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoCodecOperationFlagsKHR::NONE.0, "NONE"), + ( + VideoCodecOperationFlagsKHR::ENCODE_H264_EXT.0, + "ENCODE_H264_EXT", + ), + ( + VideoCodecOperationFlagsKHR::ENCODE_H265_EXT.0, + "ENCODE_H265_EXT", + ), + (VideoCodecOperationFlagsKHR::DECODE_H264.0, "DECODE_H264"), + (VideoCodecOperationFlagsKHR::DECODE_H265.0, "DECODE_H265"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoCodingControlFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoCodingControlFlagsKHR::RESET.0, "RESET"), + ( + VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL.0, + "ENCODE_RATE_CONTROL", + ), + ( + VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL_LAYER.0, + "ENCODE_RATE_CONTROL_LAYER", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoComponentBitDepthFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoComponentBitDepthFlagsKHR::INVALID.0, "INVALID"), + (VideoComponentBitDepthFlagsKHR::TYPE_8.0, "TYPE_8"), + (VideoComponentBitDepthFlagsKHR::TYPE_10.0, "TYPE_10"), + (VideoComponentBitDepthFlagsKHR::TYPE_12.0, "TYPE_12"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoDecodeCapabilityFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_COINCIDE.0, + "DPB_AND_OUTPUT_COINCIDE", + ), + ( + VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_DISTINCT.0, + "DPB_AND_OUTPUT_DISTINCT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoDecodeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoDecodeH264PictureLayoutFlagsKHR::PROGRESSIVE.0, + "PROGRESSIVE", + ), + ( + VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_INTERLEAVED_LINES.0, + "INTERLACED_INTERLEAVED_LINES", + ), + ( + VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_SEPARATE_PLANES.0, + "INTERLACED_SEPARATE_PLANES", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoDecodeUsageFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoDecodeUsageFlagsKHR::DEFAULT.0, "DEFAULT"), + (VideoDecodeUsageFlagsKHR::TRANSCODING.0, "TRANSCODING"), + (VideoDecodeUsageFlagsKHR::OFFLINE.0, "OFFLINE"), + (VideoDecodeUsageFlagsKHR::STREAMING.0, "STREAMING"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeCapabilityFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + VideoEncodeCapabilityFlagsKHR::PRECEDING_EXTERNALLY_ENCODED_BYTES.0, + "PRECEDING_EXTERNALLY_ENCODED_BYTES", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeContentFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeContentFlagsKHR::DEFAULT.0, "DEFAULT"), + (VideoEncodeContentFlagsKHR::CAMERA.0, "CAMERA"), + (VideoEncodeContentFlagsKHR::DESKTOP.0, "DESKTOP"), + (VideoEncodeContentFlagsKHR::RENDERED.0, "RENDERED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_ENABLED.0, + "DIRECT_8X8_INFERENCE_ENABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_DISABLED.0, + "DIRECT_8X8_INFERENCE_DISABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0, + "SEPARATE_COLOUR_PLANE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS.0, + "QPPRIME_Y_ZERO_TRANSFORM_BYPASS", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::SCALING_LISTS.0, + "SCALING_LISTS", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::HRD_COMPLIANCE.0, + "HRD_COMPLIANCE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::CHROMA_QP_OFFSET.0, + "CHROMA_QP_OFFSET", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::SECOND_CHROMA_QP_OFFSET.0, + "SECOND_CHROMA_QP_OFFSET", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::PIC_INIT_QP_MINUS26.0, + "PIC_INIT_QP_MINUS26", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED.0, + "WEIGHTED_PRED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_EXPLICIT.0, + "WEIGHTED_BIPRED_EXPLICIT", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_IMPLICIT.0, + "WEIGHTED_BIPRED_IMPLICIT", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0, + "WEIGHTED_PRED_NO_TABLE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::TRANSFORM_8X8.0, + "TRANSFORM_8X8", + ), + (VideoEncodeH264CapabilityFlagsEXT::CABAC.0, "CABAC"), + (VideoEncodeH264CapabilityFlagsEXT::CAVLC.0, "CAVLC"), + ( + VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_DISABLED.0, + "DEBLOCKING_FILTER_DISABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_ENABLED.0, + "DEBLOCKING_FILTER_ENABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0, + "DEBLOCKING_FILTER_PARTIAL", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DISABLE_DIRECT_SPATIAL_MV_PRED.0, + "DISABLE_DIRECT_SPATIAL_MV_PRED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::MULTIPLE_SLICE_PER_FRAME.0, + "MULTIPLE_SLICE_PER_FRAME", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::SLICE_MB_COUNT.0, + "SLICE_MB_COUNT", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::ROW_UNALIGNED_SLICE.0, + "ROW_UNALIGNED_SLICE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0, + "DIFFERENT_SLICE_TYPE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, + "B_FRAME_IN_L1_LIST", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264InputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH264InputModeFlagsEXT::FRAME.0, "FRAME"), + (VideoEncodeH264InputModeFlagsEXT::SLICE.0, "SLICE"), + (VideoEncodeH264InputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264OutputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH264OutputModeFlagsEXT::FRAME.0, "FRAME"), + (VideoEncodeH264OutputModeFlagsEXT::SLICE.0, "SLICE"), + (VideoEncodeH264OutputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264RateControlStructureEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::FLAT => Some("FLAT"), + Self::DYADIC => Some("DYADIC"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeH265CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0, + "SEPARATE_COLOUR_PLANE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SCALING_LISTS.0, + "SCALING_LISTS", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED.0, + "SAMPLE_ADAPTIVE_OFFSET_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::PCM_ENABLE.0, + "PCM_ENABLE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SPS_TEMPORAL_MVP_ENABLED.0, + "SPS_TEMPORAL_MVP_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::HRD_COMPLIANCE.0, + "HRD_COMPLIANCE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::INIT_QP_MINUS26.0, + "INIT_QP_MINUS26", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0, + "LOG2_PARALLEL_MERGE_LEVEL_MINUS2", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SIGN_DATA_HIDING_ENABLED.0, + "SIGN_DATA_HIDING_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_ENABLED.0, + "TRANSFORM_SKIP_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_DISABLED.0, + "TRANSFORM_SKIP_DISABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT.0, + "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED.0, + "WEIGHTED_PRED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_BIPRED.0, + "WEIGHTED_BIPRED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0, + "WEIGHTED_PRED_NO_TABLE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::TRANSQUANT_BYPASS_ENABLED.0, + "TRANSQUANT_BYPASS_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::ENTROPY_CODING_SYNC_ENABLED.0, + "ENTROPY_CODING_SYNC_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED.0, + "DEBLOCKING_FILTER_OVERRIDE_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_FRAME.0, + "MULTIPLE_TILE_PER_FRAME", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_PER_TILE.0, + "MULTIPLE_SLICE_PER_TILE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_SLICE.0, + "MULTIPLE_TILE_PER_SLICE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SLICE_SEGMENT_CTB_COUNT.0, + "SLICE_SEGMENT_CTB_COUNT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::ROW_UNALIGNED_SLICE_SEGMENT.0, + "ROW_UNALIGNED_SLICE_SEGMENT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::DEPENDENT_SLICE_SEGMENT.0, + "DEPENDENT_SLICE_SEGMENT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0, + "DIFFERENT_SLICE_TYPE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, + "B_FRAME_IN_L1_LIST", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_16.0, "TYPE_16"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_32.0, "TYPE_32"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_64.0, "TYPE_64"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265InputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265InputModeFlagsEXT::FRAME.0, "FRAME"), + ( + VideoEncodeH265InputModeFlagsEXT::SLICE_SEGMENT.0, + "SLICE_SEGMENT", + ), + (VideoEncodeH265InputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265OutputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265OutputModeFlagsEXT::FRAME.0, "FRAME"), + ( + VideoEncodeH265OutputModeFlagsEXT::SLICE_SEGMENT.0, + "SLICE_SEGMENT", + ), + (VideoEncodeH265OutputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265RateControlStructureEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::FLAT => Some("FLAT"), + Self::DYADIC => Some("DYADIC"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_4.0, + "TYPE_4", + ), + ( + VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_8.0, + "TYPE_8", + ), + ( + VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_16.0, + "TYPE_16", + ), + ( + VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_32.0, + "TYPE_32", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeRateControlFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeRateControlModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeRateControlModeFlagsKHR::NONE.0, "NONE"), + (VideoEncodeRateControlModeFlagsKHR::CBR.0, "CBR"), + (VideoEncodeRateControlModeFlagsKHR::VBR.0, "VBR"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeTuningModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::HIGH_QUALITY => Some("HIGH_QUALITY"), + Self::LOW_LATENCY => Some("LOW_LATENCY"), + Self::ULTRA_LOW_LATENCY => Some("ULTRA_LOW_LATENCY"), + Self::LOSSLESS => Some("LOSSLESS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VideoEncodeUsageFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeUsageFlagsKHR::DEFAULT.0, "DEFAULT"), + (VideoEncodeUsageFlagsKHR::TRANSCODING.0, "TRANSCODING"), + (VideoEncodeUsageFlagsKHR::STREAMING.0, "STREAMING"), + (VideoEncodeUsageFlagsKHR::RECORDING.0, "RECORDING"), + (VideoEncodeUsageFlagsKHR::CONFERENCING.0, "CONFERENCING"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEndCodingFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoSessionCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0, + "PROTECTED_CONTENT", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoSessionParametersCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for WaylandSurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for Win32SurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for XcbSurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for XlibSurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} diff --git a/third_party/rust/ash/src/vk/constants.rs b/third_party/rust/ash/src/vk/constants.rs new file mode 100644 index 0000000000..78da55ec71 --- /dev/null +++ b/third_party/rust/ash/src/vk/constants.rs @@ -0,0 +1,27 @@ +use crate::vk::definitions::*; +pub const MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256; +pub const UUID_SIZE: usize = 16; +pub const LUID_SIZE: usize = 8; +pub const MAX_EXTENSION_NAME_SIZE: usize = 256; +pub const MAX_DESCRIPTION_SIZE: usize = 256; +pub const MAX_MEMORY_TYPES: usize = 32; +#[doc = "The maximum number of unique memory heaps, each of which supporting 1 or more memory types"] +pub const MAX_MEMORY_HEAPS: usize = 16; +pub const LOD_CLAMP_NONE: f32 = 1000.00; +pub const REMAINING_MIP_LEVELS: u32 = !0; +pub const REMAINING_ARRAY_LAYERS: u32 = !0; +pub const WHOLE_SIZE: u64 = !0; +pub const ATTACHMENT_UNUSED: u32 = !0; +pub const TRUE: Bool32 = 1; +pub const FALSE: Bool32 = 0; +pub const QUEUE_FAMILY_IGNORED: u32 = !0; +pub const QUEUE_FAMILY_EXTERNAL: u32 = !1; +pub const QUEUE_FAMILY_FOREIGN_EXT: u32 = !2; +pub const SUBPASS_EXTERNAL: u32 = !0; +pub const MAX_DEVICE_GROUP_SIZE: usize = 32; +pub const MAX_DRIVER_NAME_SIZE: usize = 256; +pub const MAX_DRIVER_INFO_SIZE: usize = 256; +pub const SHADER_UNUSED_KHR: u32 = !0; +pub const MAX_GLOBAL_PRIORITY_SIZE_KHR: usize = 16; +pub const MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: usize = 32; +pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR; diff --git a/third_party/rust/ash/src/vk/definitions.rs b/third_party/rust/ash/src/vk/definitions.rs new file mode 100644 index 0000000000..c73770b05e --- /dev/null +++ b/third_party/rust/ash/src/vk/definitions.rs @@ -0,0 +1,73178 @@ +use crate::vk::aliases::*; +use crate::vk::bitflags::*; +use crate::vk::constants::*; +use crate::vk::enums::*; +use crate::vk::native::*; +use crate::vk::platform_types::*; +use crate::vk::prelude::*; +use crate::vk::{ptr_chain_iter, Handle}; +use std::fmt; +use std::os::raw::*; +#[deprecated = "This define is deprecated. VK_MAKE_API_VERSION should be used instead."] +#[doc = ""] +pub const fn make_version(major: u32, minor: u32, patch: u32) -> u32 { + ((major) << 22) | ((minor) << 12) | (patch) +} +#[deprecated = "This define is deprecated. VK_API_VERSION_MAJOR should be used instead."] +#[doc = ""] +pub const fn version_major(version: u32) -> u32 { + (version) >> 22 +} +#[deprecated = "This define is deprecated. VK_API_VERSION_MINOR should be used instead."] +#[doc = ""] +pub const fn version_minor(version: u32) -> u32 { + ((version) >> 12) & 0x3ffu32 +} +#[deprecated = "This define is deprecated. VK_API_VERSION_PATCH should be used instead."] +#[doc = ""] +pub const fn version_patch(version: u32) -> u32 { + (version) & 0xfffu32 +} +#[doc = ""] +pub const fn make_api_version(variant: u32, major: u32, minor: u32, patch: u32) -> u32 { + ((variant) << 29) | ((major) << 22) | ((minor) << 12) | (patch) +} +#[doc = ""] +pub const fn api_version_variant(version: u32) -> u32 { + (version) >> 29 +} +#[doc = ""] +pub const fn api_version_major(version: u32) -> u32 { + ((version) >> 22) & 0x7fu32 +} +#[doc = ""] +pub const fn api_version_minor(version: u32) -> u32 { + ((version) >> 12) & 0x3ffu32 +} +#[doc = ""] +pub const fn api_version_patch(version: u32) -> u32 { + (version) & 0xfffu32 +} +#[doc = ""] +pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0); +#[doc = ""] +pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); +#[doc = ""] +pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); +#[doc = ""] +pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); +pub const HEADER_VERSION: u32 = 238u32; +#[doc = ""] +pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); +#[doc = ""] +pub type SampleMask = u32; +#[doc = ""] +pub type Bool32 = u32; +#[doc = ""] +pub type Flags = u32; +#[doc = ""] +pub type Flags64 = u64; +#[doc = ""] +pub type DeviceSize = u64; +#[doc = ""] +pub type DeviceAddress = u64; +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueryPoolCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryPoolCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineViewportStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BufferViewCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(BufferViewCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryMapFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryMapFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorPoolResetFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorPoolResetFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccelerationStructureMotionInfoFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DirectDriverLoadingFlagsLUNARG(pub(crate) Flags); +vk_bitflags_wrapped!(DirectDriverLoadingFlagsLUNARG, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags); +vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags); +vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags); +vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags); +vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags); +vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ScreenSurfaceCreateFlagsQNX(pub(crate) Flags); +vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandPoolTrimFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandPoolTrimFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineRasterizationConservativeStateCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineRasterizationDepthClipStateCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoSessionParametersCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoSessionParametersCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoBeginCodingFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEndCodingFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags); +define_handle!( + Instance, + INSTANCE, + doc = "" +); +define_handle ! (PhysicalDevice , PHYSICAL_DEVICE , doc = "") ; +define_handle!( + Device, + DEVICE, + doc = "" +); +define_handle!( + Queue, + QUEUE, + doc = "" +); +define_handle ! (CommandBuffer , COMMAND_BUFFER , doc = "") ; +handle_nondispatchable ! (DeviceMemory , DEVICE_MEMORY , doc = "") ; +handle_nondispatchable ! (CommandPool , COMMAND_POOL , doc = "") ; +handle_nondispatchable!( + Buffer, + BUFFER, + doc = "" +); +handle_nondispatchable!( + BufferView, + BUFFER_VIEW, + doc = + "" +); +handle_nondispatchable!( + Image, + IMAGE, + doc = "" +); +handle_nondispatchable!( + ImageView, + IMAGE_VIEW, + doc = + "" +); +handle_nondispatchable ! (ShaderModule , SHADER_MODULE , doc = "") ; +handle_nondispatchable!( + Pipeline, + PIPELINE, + doc = "" +); +handle_nondispatchable ! (PipelineLayout , PIPELINE_LAYOUT , doc = "") ; +handle_nondispatchable!( + Sampler, + SAMPLER, + doc = "" +); +handle_nondispatchable ! (DescriptorSet , DESCRIPTOR_SET , doc = "") ; +handle_nondispatchable ! (DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "") ; +handle_nondispatchable ! (DescriptorPool , DESCRIPTOR_POOL , doc = "") ; +handle_nondispatchable!( + Fence, + FENCE, + doc = "" +); +handle_nondispatchable!( + Semaphore, + SEMAPHORE, + doc = + "" +); +handle_nondispatchable!( + Event, + EVENT, + doc = "" +); +handle_nondispatchable!( + QueryPool, + QUERY_POOL, + doc = + "" +); +handle_nondispatchable ! (Framebuffer , FRAMEBUFFER , doc = "") ; +handle_nondispatchable!( + RenderPass, + RENDER_PASS, + doc = + "" +); +handle_nondispatchable ! (PipelineCache , PIPELINE_CACHE , doc = "") ; +handle_nondispatchable ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "") ; +handle_nondispatchable ! (DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "") ; +handle_nondispatchable ! (SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "") ; +handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "") ; +handle_nondispatchable ! (AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "") ; +handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "") ; +handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "") ; +handle_nondispatchable ! (BufferCollectionFUCHSIA , BUFFER_COLLECTION_FUCHSIA , doc = "") ; +handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "") ; +handle_nondispatchable ! (PrivateDataSlot , PRIVATE_DATA_SLOT , doc = "") ; +handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "") ; +handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "") ; +handle_nondispatchable ! (OpticalFlowSessionNV , OPTICAL_FLOW_SESSION_NV , doc = "") ; +handle_nondispatchable ! (MicromapEXT , MICROMAP_EXT , doc = "") ; +handle_nondispatchable!( + DisplayKHR, + DISPLAY_KHR, + doc = + "" +); +handle_nondispatchable ! (DisplayModeKHR , DISPLAY_MODE_KHR , doc = "") ; +handle_nondispatchable!( + SurfaceKHR, + SURFACE_KHR, + doc = + "" +); +handle_nondispatchable ! (SwapchainKHR , SWAPCHAIN_KHR , doc = "") ; +handle_nondispatchable ! (DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "") ; +handle_nondispatchable ! (DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "") ; +handle_nondispatchable ! (VideoSessionKHR , VIDEO_SESSION_KHR , doc = "") ; +handle_nondispatchable ! (VideoSessionParametersKHR , VIDEO_SESSION_PARAMETERS_KHR , doc = "") ; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkInternalAllocationNotification = Option< + unsafe extern "system" fn( + p_user_data: *mut c_void, + size: usize, + allocation_type: InternalAllocationType, + allocation_scope: SystemAllocationScope, + ), +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkInternalFreeNotification = Option< + unsafe extern "system" fn( + p_user_data: *mut c_void, + size: usize, + allocation_type: InternalAllocationType, + allocation_scope: SystemAllocationScope, + ), +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkReallocationFunction = Option< + unsafe extern "system" fn( + p_user_data: *mut c_void, + p_original: *mut c_void, + size: usize, + alignment: usize, + allocation_scope: SystemAllocationScope, + ) -> *mut c_void, +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkAllocationFunction = Option< + unsafe extern "system" fn( + p_user_data: *mut c_void, + size: usize, + alignment: usize, + allocation_scope: SystemAllocationScope, + ) -> *mut c_void, +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkFreeFunction = + Option; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkVoidFunction = Option; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkDebugReportCallbackEXT = Option< + unsafe extern "system" fn( + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: u64, + location: usize, + message_code: i32, + p_layer_prefix: *const c_char, + p_message: *const c_char, + p_user_data: *mut c_void, + ) -> Bool32, +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option< + unsafe extern "system" fn( + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_types: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + p_user_data: *mut c_void, + ) -> Bool32, +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkDeviceMemoryReportCallbackEXT = Option< + unsafe extern "system" fn( + p_callback_data: *const DeviceMemoryReportCallbackDataEXT, + p_user_data: *mut c_void, + ), +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkGetInstanceProcAddrLUNARG = Option< + unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction, +>; +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BaseOutStructure { + pub s_type: StructureType, + pub p_next: *mut Self, +} +impl ::std::default::Default for BaseOutStructure { + #[inline] + fn default() -> Self { + Self { + s_type: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), + } + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BaseInStructure { + pub s_type: StructureType, + pub p_next: *const Self, +} +impl ::std::default::Default for BaseInStructure { + #[inline] + fn default() -> Self { + Self { + s_type: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + } + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Offset2D { + pub x: i32, + pub y: i32, +} +impl Offset2D { + pub fn builder<'a>() -> Offset2DBuilder<'a> { + Offset2DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Offset2DBuilder<'a> { + inner: Offset2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> { + type Target = Offset2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Offset2DBuilder<'a> { + #[inline] + pub fn x(mut self, x: i32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: i32) -> Self { + self.inner.y = y; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Offset2D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Offset3D { + pub x: i32, + pub y: i32, + pub z: i32, +} +impl Offset3D { + pub fn builder<'a>() -> Offset3DBuilder<'a> { + Offset3DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Offset3DBuilder<'a> { + inner: Offset3D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> { + type Target = Offset3D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Offset3DBuilder<'a> { + #[inline] + pub fn x(mut self, x: i32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: i32) -> Self { + self.inner.y = y; + self + } + #[inline] + pub fn z(mut self, z: i32) -> Self { + self.inner.z = z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Offset3D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Extent2D { + pub width: u32, + pub height: u32, +} +impl Extent2D { + pub fn builder<'a>() -> Extent2DBuilder<'a> { + Extent2DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Extent2DBuilder<'a> { + inner: Extent2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> { + type Target = Extent2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Extent2DBuilder<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Extent2D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Extent3D { + pub width: u32, + pub height: u32, + pub depth: u32, +} +impl Extent3D { + pub fn builder<'a>() -> Extent3DBuilder<'a> { + Extent3DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Extent3DBuilder<'a> { + inner: Extent3D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> { + type Target = Extent3D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Extent3DBuilder<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn depth(mut self, depth: u32) -> Self { + self.inner.depth = depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Extent3D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct Viewport { + pub x: f32, + pub y: f32, + pub width: f32, + pub height: f32, + pub min_depth: f32, + pub max_depth: f32, +} +impl Viewport { + pub fn builder<'a>() -> ViewportBuilder<'a> { + ViewportBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ViewportBuilder<'a> { + inner: Viewport, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportBuilder<'a> { + type Target = Viewport; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ViewportBuilder<'a> { + #[inline] + pub fn x(mut self, x: f32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: f32) -> Self { + self.inner.y = y; + self + } + #[inline] + pub fn width(mut self, width: f32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: f32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn min_depth(mut self, min_depth: f32) -> Self { + self.inner.min_depth = min_depth; + self + } + #[inline] + pub fn max_depth(mut self, max_depth: f32) -> Self { + self.inner.max_depth = max_depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Viewport { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Rect2D { + pub offset: Offset2D, + pub extent: Extent2D, +} +impl Rect2D { + pub fn builder<'a>() -> Rect2DBuilder<'a> { + Rect2DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Rect2DBuilder<'a> { + inner: Rect2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> { + type Target = Rect2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Rect2DBuilder<'a> { + #[inline] + pub fn offset(mut self, offset: Offset2D) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent2D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Rect2D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct ClearRect { + pub rect: Rect2D, + pub base_array_layer: u32, + pub layer_count: u32, +} +impl ClearRect { + pub fn builder<'a>() -> ClearRectBuilder<'a> { + ClearRectBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ClearRectBuilder<'a> { + inner: ClearRect, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> { + type Target = ClearRect; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ClearRectBuilder<'a> { + #[inline] + pub fn rect(mut self, rect: Rect2D) -> Self { + self.inner.rect = rect; + self + } + #[inline] + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.inner.base_array_layer = base_array_layer; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ClearRect { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ComponentMapping { + pub r: ComponentSwizzle, + pub g: ComponentSwizzle, + pub b: ComponentSwizzle, + pub a: ComponentSwizzle, +} +impl ComponentMapping { + pub fn builder<'a>() -> ComponentMappingBuilder<'a> { + ComponentMappingBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ComponentMappingBuilder<'a> { + inner: ComponentMapping, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> { + type Target = ComponentMapping; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ComponentMappingBuilder<'a> { + #[inline] + pub fn r(mut self, r: ComponentSwizzle) -> Self { + self.inner.r = r; + self + } + #[inline] + pub fn g(mut self, g: ComponentSwizzle) -> Self { + self.inner.g = g; + self + } + #[inline] + pub fn b(mut self, b: ComponentSwizzle) -> Self { + self.inner.b = b; + self + } + #[inline] + pub fn a(mut self, a: ComponentSwizzle) -> Self { + self.inner.a = a; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ComponentMapping { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProperties { + pub api_version: u32, + pub driver_version: u32, + pub vendor_id: u32, + pub device_id: u32, + pub device_type: PhysicalDeviceType, + pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE], + pub pipeline_cache_uuid: [u8; UUID_SIZE], + pub limits: PhysicalDeviceLimits, + pub sparse_properties: PhysicalDeviceSparseProperties, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PhysicalDeviceProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PhysicalDeviceProperties") + .field("api_version", &self.api_version) + .field("driver_version", &self.driver_version) + .field("vendor_id", &self.vendor_id) + .field("device_id", &self.device_id) + .field("device_type", &self.device_type) + .field("device_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.device_name.as_ptr()) + }) + .field("pipeline_cache_uuid", &self.pipeline_cache_uuid) + .field("limits", &self.limits) + .field("sparse_properties", &self.sparse_properties) + .finish() + } +} +impl ::std::default::Default for PhysicalDeviceProperties { + #[inline] + fn default() -> Self { + Self { + api_version: u32::default(), + driver_version: u32::default(), + vendor_id: u32::default(), + device_id: u32::default(), + device_type: PhysicalDeviceType::default(), + device_name: unsafe { ::std::mem::zeroed() }, + pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, + limits: PhysicalDeviceLimits::default(), + sparse_properties: PhysicalDeviceSparseProperties::default(), + } + } +} +impl PhysicalDeviceProperties { + pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> { + PhysicalDevicePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePropertiesBuilder<'a> { + inner: PhysicalDeviceProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> { + type Target = PhysicalDeviceProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePropertiesBuilder<'a> { + #[inline] + pub fn api_version(mut self, api_version: u32) -> Self { + self.inner.api_version = api_version; + self + } + #[inline] + pub fn driver_version(mut self, driver_version: u32) -> Self { + self.inner.driver_version = driver_version; + self + } + #[inline] + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.inner.vendor_id = vendor_id; + self + } + #[inline] + pub fn device_id(mut self, device_id: u32) -> Self { + self.inner.device_id = device_id; + self + } + #[inline] + pub fn device_type(mut self, device_type: PhysicalDeviceType) -> Self { + self.inner.device_type = device_type; + self + } + #[inline] + pub fn device_name(mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE]) -> Self { + self.inner.device_name = device_name; + self + } + #[inline] + pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + #[inline] + pub fn limits(mut self, limits: PhysicalDeviceLimits) -> Self { + self.inner.limits = limits; + self + } + #[inline] + pub fn sparse_properties(mut self, sparse_properties: PhysicalDeviceSparseProperties) -> Self { + self.inner.sparse_properties = sparse_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProperties { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExtensionProperties { + pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], + pub spec_version: u32, +} +#[cfg(feature = "debug")] +impl fmt::Debug for ExtensionProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("ExtensionProperties") + .field("extension_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr()) + }) + .field("spec_version", &self.spec_version) + .finish() + } +} +impl ::std::default::Default for ExtensionProperties { + #[inline] + fn default() -> Self { + Self { + extension_name: unsafe { ::std::mem::zeroed() }, + spec_version: u32::default(), + } + } +} +impl ExtensionProperties { + pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> { + ExtensionPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExtensionPropertiesBuilder<'a> { + inner: ExtensionProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> { + type Target = ExtensionProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExtensionPropertiesBuilder<'a> { + #[inline] + pub fn extension_name(mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.extension_name = extension_name; + self + } + #[inline] + pub fn spec_version(mut self, spec_version: u32) -> Self { + self.inner.spec_version = spec_version; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExtensionProperties { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct LayerProperties { + pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE], + pub spec_version: u32, + pub implementation_version: u32, + pub description: [c_char; MAX_DESCRIPTION_SIZE], +} +#[cfg(feature = "debug")] +impl fmt::Debug for LayerProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("LayerProperties") + .field("layer_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr()) + }) + .field("spec_version", &self.spec_version) + .field("implementation_version", &self.implementation_version) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .finish() + } +} +impl ::std::default::Default for LayerProperties { + #[inline] + fn default() -> Self { + Self { + layer_name: unsafe { ::std::mem::zeroed() }, + spec_version: u32::default(), + implementation_version: u32::default(), + description: unsafe { ::std::mem::zeroed() }, + } + } +} +impl LayerProperties { + pub fn builder<'a>() -> LayerPropertiesBuilder<'a> { + LayerPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct LayerPropertiesBuilder<'a> { + inner: LayerProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> { + type Target = LayerProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> LayerPropertiesBuilder<'a> { + #[inline] + pub fn layer_name(mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.layer_name = layer_name; + self + } + #[inline] + pub fn spec_version(mut self, spec_version: u32) -> Self { + self.inner.spec_version = spec_version; + self + } + #[inline] + pub fn implementation_version(mut self, implementation_version: u32) -> Self { + self.inner.implementation_version = implementation_version; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> LayerProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ApplicationInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_application_name: *const c_char, + pub application_version: u32, + pub p_engine_name: *const c_char, + pub engine_version: u32, + pub api_version: u32, +} +impl ::std::default::Default for ApplicationInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_application_name: ::std::ptr::null(), + application_version: u32::default(), + p_engine_name: ::std::ptr::null(), + engine_version: u32::default(), + api_version: u32::default(), + } + } +} +unsafe impl TaggedStructure for ApplicationInfo { + const STRUCTURE_TYPE: StructureType = StructureType::APPLICATION_INFO; +} +impl ApplicationInfo { + pub fn builder<'a>() -> ApplicationInfoBuilder<'a> { + ApplicationInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ApplicationInfoBuilder<'a> { + inner: ApplicationInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> { + type Target = ApplicationInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ApplicationInfoBuilder<'a> { + #[inline] + pub fn application_name(mut self, application_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_application_name = application_name.as_ptr(); + self + } + #[inline] + pub fn application_version(mut self, application_version: u32) -> Self { + self.inner.application_version = application_version; + self + } + #[inline] + pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_engine_name = engine_name.as_ptr(); + self + } + #[inline] + pub fn engine_version(mut self, engine_version: u32) -> Self { + self.inner.engine_version = engine_version; + self + } + #[inline] + pub fn api_version(mut self, api_version: u32) -> Self { + self.inner.api_version = api_version; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ApplicationInfo { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AllocationCallbacks { + pub p_user_data: *mut c_void, + pub pfn_allocation: PFN_vkAllocationFunction, + pub pfn_reallocation: PFN_vkReallocationFunction, + pub pfn_free: PFN_vkFreeFunction, + pub pfn_internal_allocation: PFN_vkInternalAllocationNotification, + pub pfn_internal_free: PFN_vkInternalFreeNotification, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AllocationCallbacks { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AllocationCallbacks") + .field("p_user_data", &self.p_user_data) + .field( + "pfn_allocation", + &(self.pfn_allocation.map(|x| x as *const ())), + ) + .field( + "pfn_reallocation", + &(self.pfn_reallocation.map(|x| x as *const ())), + ) + .field("pfn_free", &(self.pfn_free.map(|x| x as *const ()))) + .field( + "pfn_internal_allocation", + &(self.pfn_internal_allocation.map(|x| x as *const ())), + ) + .field( + "pfn_internal_free", + &(self.pfn_internal_free.map(|x| x as *const ())), + ) + .finish() + } +} +impl ::std::default::Default for AllocationCallbacks { + #[inline] + fn default() -> Self { + Self { + p_user_data: ::std::ptr::null_mut(), + pfn_allocation: PFN_vkAllocationFunction::default(), + pfn_reallocation: PFN_vkReallocationFunction::default(), + pfn_free: PFN_vkFreeFunction::default(), + pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(), + pfn_internal_free: PFN_vkInternalFreeNotification::default(), + } + } +} +impl AllocationCallbacks { + pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> { + AllocationCallbacksBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AllocationCallbacksBuilder<'a> { + inner: AllocationCallbacks, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> { + type Target = AllocationCallbacks; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AllocationCallbacksBuilder<'a> { + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[inline] + pub fn pfn_allocation(mut self, pfn_allocation: PFN_vkAllocationFunction) -> Self { + self.inner.pfn_allocation = pfn_allocation; + self + } + #[inline] + pub fn pfn_reallocation(mut self, pfn_reallocation: PFN_vkReallocationFunction) -> Self { + self.inner.pfn_reallocation = pfn_reallocation; + self + } + #[inline] + pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> Self { + self.inner.pfn_free = pfn_free; + self + } + #[inline] + pub fn pfn_internal_allocation( + mut self, + pfn_internal_allocation: PFN_vkInternalAllocationNotification, + ) -> Self { + self.inner.pfn_internal_allocation = pfn_internal_allocation; + self + } + #[inline] + pub fn pfn_internal_free(mut self, pfn_internal_free: PFN_vkInternalFreeNotification) -> Self { + self.inner.pfn_internal_free = pfn_internal_free; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AllocationCallbacks { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceQueueCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceQueueCreateFlags, + pub queue_family_index: u32, + pub queue_count: u32, + pub p_queue_priorities: *const f32, +} +impl ::std::default::Default for DeviceQueueCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceQueueCreateFlags::default(), + queue_family_index: u32::default(), + queue_count: u32::default(), + p_queue_priorities: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceQueueCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_QUEUE_CREATE_INFO; +} +impl DeviceQueueCreateInfo { + pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> { + DeviceQueueCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceQueueCreateInfoBuilder<'a> { + inner: DeviceQueueCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDeviceQueueCreateInfo {} +impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> { + type Target = DeviceQueueCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceQueueCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[inline] + pub fn queue_priorities(mut self, queue_priorities: &'a [f32]) -> Self { + self.inner.queue_count = queue_priorities.len() as _; + self.inner.p_queue_priorities = queue_priorities.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceQueueCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceCreateFlags, + pub queue_create_info_count: u32, + pub p_queue_create_infos: *const DeviceQueueCreateInfo, + pub enabled_layer_count: u32, + pub pp_enabled_layer_names: *const *const c_char, + pub enabled_extension_count: u32, + pub pp_enabled_extension_names: *const *const c_char, + pub p_enabled_features: *const PhysicalDeviceFeatures, +} +impl ::std::default::Default for DeviceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceCreateFlags::default(), + queue_create_info_count: u32::default(), + p_queue_create_infos: ::std::ptr::null(), + enabled_layer_count: u32::default(), + pp_enabled_layer_names: ::std::ptr::null(), + enabled_extension_count: u32::default(), + pp_enabled_extension_names: ::std::ptr::null(), + p_enabled_features: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_CREATE_INFO; +} +impl DeviceCreateInfo { + pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> { + DeviceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceCreateInfoBuilder<'a> { + inner: DeviceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDeviceCreateInfo {} +impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> { + type Target = DeviceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn queue_create_infos(mut self, queue_create_infos: &'a [DeviceQueueCreateInfo]) -> Self { + self.inner.queue_create_info_count = queue_create_infos.len() as _; + self.inner.p_queue_create_infos = queue_create_infos.as_ptr(); + self + } + #[inline] + pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self { + self.inner.enabled_layer_count = enabled_layer_names.len() as _; + self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr(); + self + } + #[inline] + pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self { + self.inner.enabled_extension_count = enabled_extension_names.len() as _; + self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr(); + self + } + #[inline] + pub fn enabled_features(mut self, enabled_features: &'a PhysicalDeviceFeatures) -> Self { + self.inner.p_enabled_features = enabled_features; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct InstanceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: InstanceCreateFlags, + pub p_application_info: *const ApplicationInfo, + pub enabled_layer_count: u32, + pub pp_enabled_layer_names: *const *const c_char, + pub enabled_extension_count: u32, + pub pp_enabled_extension_names: *const *const c_char, +} +impl ::std::default::Default for InstanceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: InstanceCreateFlags::default(), + p_application_info: ::std::ptr::null(), + enabled_layer_count: u32::default(), + pp_enabled_layer_names: ::std::ptr::null(), + enabled_extension_count: u32::default(), + pp_enabled_extension_names: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for InstanceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::INSTANCE_CREATE_INFO; +} +impl InstanceCreateInfo { + pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> { + InstanceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct InstanceCreateInfoBuilder<'a> { + inner: InstanceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsInstanceCreateInfo {} +impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> { + type Target = InstanceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> InstanceCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: InstanceCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn application_info(mut self, application_info: &'a ApplicationInfo) -> Self { + self.inner.p_application_info = application_info; + self + } + #[inline] + pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self { + self.inner.enabled_layer_count = enabled_layer_names.len() as _; + self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr(); + self + } + #[inline] + pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self { + self.inner.enabled_extension_count = enabled_extension_names.len() as _; + self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> InstanceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct QueueFamilyProperties { + pub queue_flags: QueueFlags, + pub queue_count: u32, + pub timestamp_valid_bits: u32, + pub min_image_transfer_granularity: Extent3D, +} +impl QueueFamilyProperties { + pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> { + QueueFamilyPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyPropertiesBuilder<'a> { + inner: QueueFamilyProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> { + type Target = QueueFamilyProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyPropertiesBuilder<'a> { + #[inline] + pub fn queue_flags(mut self, queue_flags: QueueFlags) -> Self { + self.inner.queue_flags = queue_flags; + self + } + #[inline] + pub fn queue_count(mut self, queue_count: u32) -> Self { + self.inner.queue_count = queue_count; + self + } + #[inline] + pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self { + self.inner.timestamp_valid_bits = timestamp_valid_bits; + self + } + #[inline] + pub fn min_image_transfer_granularity( + mut self, + min_image_transfer_granularity: Extent3D, + ) -> Self { + self.inner.min_image_transfer_granularity = min_image_transfer_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryProperties { + pub memory_type_count: u32, + pub memory_types: [MemoryType; MAX_MEMORY_TYPES], + pub memory_heap_count: u32, + pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], +} +impl ::std::default::Default for PhysicalDeviceMemoryProperties { + #[inline] + fn default() -> Self { + Self { + memory_type_count: u32::default(), + memory_types: unsafe { ::std::mem::zeroed() }, + memory_heap_count: u32::default(), + memory_heaps: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PhysicalDeviceMemoryProperties { + pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> { + PhysicalDeviceMemoryPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> { + inner: PhysicalDeviceMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> { + type Target = PhysicalDeviceMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> { + #[inline] + pub fn memory_type_count(mut self, memory_type_count: u32) -> Self { + self.inner.memory_type_count = memory_type_count; + self + } + #[inline] + pub fn memory_types(mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES]) -> Self { + self.inner.memory_types = memory_types; + self + } + #[inline] + pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self { + self.inner.memory_heap_count = memory_heap_count; + self + } + #[inline] + pub fn memory_heaps(mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS]) -> Self { + self.inner.memory_heaps = memory_heaps; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub allocation_size: DeviceSize, + pub memory_type_index: u32, +} +impl ::std::default::Default for MemoryAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + allocation_size: DeviceSize::default(), + memory_type_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ALLOCATE_INFO; +} +impl MemoryAllocateInfo { + pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> { + MemoryAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryAllocateInfoBuilder<'a> { + inner: MemoryAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsMemoryAllocateInfo {} +impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> { + type Target = MemoryAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryAllocateInfoBuilder<'a> { + #[inline] + pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self { + self.inner.allocation_size = allocation_size; + self + } + #[inline] + pub fn memory_type_index(mut self, memory_type_index: u32) -> Self { + self.inner.memory_type_index = memory_type_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MemoryRequirements { + pub size: DeviceSize, + pub alignment: DeviceSize, + pub memory_type_bits: u32, +} +impl MemoryRequirements { + pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> { + MemoryRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryRequirementsBuilder<'a> { + inner: MemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> { + type Target = MemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryRequirementsBuilder<'a> { + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn alignment(mut self, alignment: DeviceSize) -> Self { + self.inner.alignment = alignment; + self + } + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SparseImageFormatProperties { + pub aspect_mask: ImageAspectFlags, + pub image_granularity: Extent3D, + pub flags: SparseImageFormatFlags, +} +impl SparseImageFormatProperties { + pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> { + SparseImageFormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageFormatPropertiesBuilder<'a> { + inner: SparseImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> { + type Target = SparseImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageFormatPropertiesBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn image_granularity(mut self, image_granularity: Extent3D) -> Self { + self.inner.image_granularity = image_granularity; + self + } + #[inline] + pub fn flags(mut self, flags: SparseImageFormatFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageFormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SparseImageMemoryRequirements { + pub format_properties: SparseImageFormatProperties, + pub image_mip_tail_first_lod: u32, + pub image_mip_tail_size: DeviceSize, + pub image_mip_tail_offset: DeviceSize, + pub image_mip_tail_stride: DeviceSize, +} +impl SparseImageMemoryRequirements { + pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> { + SparseImageMemoryRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageMemoryRequirementsBuilder<'a> { + inner: SparseImageMemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> { + type Target = SparseImageMemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageMemoryRequirementsBuilder<'a> { + #[inline] + pub fn format_properties(mut self, format_properties: SparseImageFormatProperties) -> Self { + self.inner.format_properties = format_properties; + self + } + #[inline] + pub fn image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self { + self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod; + self + } + #[inline] + pub fn image_mip_tail_size(mut self, image_mip_tail_size: DeviceSize) -> Self { + self.inner.image_mip_tail_size = image_mip_tail_size; + self + } + #[inline] + pub fn image_mip_tail_offset(mut self, image_mip_tail_offset: DeviceSize) -> Self { + self.inner.image_mip_tail_offset = image_mip_tail_offset; + self + } + #[inline] + pub fn image_mip_tail_stride(mut self, image_mip_tail_stride: DeviceSize) -> Self { + self.inner.image_mip_tail_stride = image_mip_tail_stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageMemoryRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MemoryType { + pub property_flags: MemoryPropertyFlags, + pub heap_index: u32, +} +impl MemoryType { + pub fn builder<'a>() -> MemoryTypeBuilder<'a> { + MemoryTypeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryTypeBuilder<'a> { + inner: MemoryType, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> { + type Target = MemoryType; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryTypeBuilder<'a> { + #[inline] + pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> Self { + self.inner.property_flags = property_flags; + self + } + #[inline] + pub fn heap_index(mut self, heap_index: u32) -> Self { + self.inner.heap_index = heap_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryType { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MemoryHeap { + pub size: DeviceSize, + pub flags: MemoryHeapFlags, +} +impl MemoryHeap { + pub fn builder<'a>() -> MemoryHeapBuilder<'a> { + MemoryHeapBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryHeapBuilder<'a> { + inner: MemoryHeap, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> { + type Target = MemoryHeap; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryHeapBuilder<'a> { + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn flags(mut self, flags: MemoryHeapFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryHeap { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MappedMemoryRange { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for MappedMemoryRange { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for MappedMemoryRange { + const STRUCTURE_TYPE: StructureType = StructureType::MAPPED_MEMORY_RANGE; +} +impl MappedMemoryRange { + pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> { + MappedMemoryRangeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MappedMemoryRangeBuilder<'a> { + inner: MappedMemoryRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> { + type Target = MappedMemoryRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MappedMemoryRangeBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MappedMemoryRange { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct FormatProperties { + pub linear_tiling_features: FormatFeatureFlags, + pub optimal_tiling_features: FormatFeatureFlags, + pub buffer_features: FormatFeatureFlags, +} +impl FormatProperties { + pub fn builder<'a>() -> FormatPropertiesBuilder<'a> { + FormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FormatPropertiesBuilder<'a> { + inner: FormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> { + type Target = FormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FormatPropertiesBuilder<'a> { + #[inline] + pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags) -> Self { + self.inner.linear_tiling_features = linear_tiling_features; + self + } + #[inline] + pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags) -> Self { + self.inner.optimal_tiling_features = optimal_tiling_features; + self + } + #[inline] + pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags) -> Self { + self.inner.buffer_features = buffer_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageFormatProperties { + pub max_extent: Extent3D, + pub max_mip_levels: u32, + pub max_array_layers: u32, + pub sample_counts: SampleCountFlags, + pub max_resource_size: DeviceSize, +} +impl ImageFormatProperties { + pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> { + ImageFormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatPropertiesBuilder<'a> { + inner: ImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> { + type Target = ImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatPropertiesBuilder<'a> { + #[inline] + pub fn max_extent(mut self, max_extent: Extent3D) -> Self { + self.inner.max_extent = max_extent; + self + } + #[inline] + pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self { + self.inner.max_mip_levels = max_mip_levels; + self + } + #[inline] + pub fn max_array_layers(mut self, max_array_layers: u32) -> Self { + self.inner.max_array_layers = max_array_layers; + self + } + #[inline] + pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self { + self.inner.sample_counts = sample_counts; + self + } + #[inline] + pub fn max_resource_size(mut self, max_resource_size: DeviceSize) -> Self { + self.inner.max_resource_size = max_resource_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DescriptorBufferInfo { + pub buffer: Buffer, + pub offset: DeviceSize, + pub range: DeviceSize, +} +impl DescriptorBufferInfo { + pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> { + DescriptorBufferInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorBufferInfoBuilder<'a> { + inner: DescriptorBufferInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> { + type Target = DescriptorBufferInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorBufferInfoBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn range(mut self, range: DeviceSize) -> Self { + self.inner.range = range; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorBufferInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DescriptorImageInfo { + pub sampler: Sampler, + pub image_view: ImageView, + pub image_layout: ImageLayout, +} +impl DescriptorImageInfo { + pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> { + DescriptorImageInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorImageInfoBuilder<'a> { + inner: DescriptorImageInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> { + type Target = DescriptorImageInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorImageInfoBuilder<'a> { + #[inline] + pub fn sampler(mut self, sampler: Sampler) -> Self { + self.inner.sampler = sampler; + self + } + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorImageInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WriteDescriptorSet { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dst_set: DescriptorSet, + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, + pub descriptor_type: DescriptorType, + pub p_image_info: *const DescriptorImageInfo, + pub p_buffer_info: *const DescriptorBufferInfo, + pub p_texel_buffer_view: *const BufferView, +} +impl ::std::default::Default for WriteDescriptorSet { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + dst_set: DescriptorSet::default(), + dst_binding: u32::default(), + dst_array_element: u32::default(), + descriptor_count: u32::default(), + descriptor_type: DescriptorType::default(), + p_image_info: ::std::ptr::null(), + p_buffer_info: ::std::ptr::null(), + p_texel_buffer_view: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for WriteDescriptorSet { + const STRUCTURE_TYPE: StructureType = StructureType::WRITE_DESCRIPTOR_SET; +} +impl WriteDescriptorSet { + pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> { + WriteDescriptorSetBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WriteDescriptorSetBuilder<'a> { + inner: WriteDescriptorSet, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsWriteDescriptorSet {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> { + type Target = WriteDescriptorSet; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WriteDescriptorSetBuilder<'a> { + #[inline] + pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self { + self.inner.dst_set = dst_set; + self + } + #[inline] + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.inner.dst_binding = dst_binding; + self + } + #[inline] + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.inner.dst_array_element = dst_array_element; + self + } + #[inline] + pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { + self.inner.descriptor_type = descriptor_type; + self + } + #[inline] + pub fn image_info(mut self, image_info: &'a [DescriptorImageInfo]) -> Self { + self.inner.descriptor_count = image_info.len() as _; + self.inner.p_image_info = image_info.as_ptr(); + self + } + #[inline] + pub fn buffer_info(mut self, buffer_info: &'a [DescriptorBufferInfo]) -> Self { + self.inner.descriptor_count = buffer_info.len() as _; + self.inner.p_buffer_info = buffer_info.as_ptr(); + self + } + #[inline] + pub fn texel_buffer_view(mut self, texel_buffer_view: &'a [BufferView]) -> Self { + self.inner.descriptor_count = texel_buffer_view.len() as _; + self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WriteDescriptorSet { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyDescriptorSet { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_set: DescriptorSet, + pub src_binding: u32, + pub src_array_element: u32, + pub dst_set: DescriptorSet, + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, +} +impl ::std::default::Default for CopyDescriptorSet { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_set: DescriptorSet::default(), + src_binding: u32::default(), + src_array_element: u32::default(), + dst_set: DescriptorSet::default(), + dst_binding: u32::default(), + dst_array_element: u32::default(), + descriptor_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for CopyDescriptorSet { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_DESCRIPTOR_SET; +} +impl CopyDescriptorSet { + pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> { + CopyDescriptorSetBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyDescriptorSetBuilder<'a> { + inner: CopyDescriptorSet, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> { + type Target = CopyDescriptorSet; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyDescriptorSetBuilder<'a> { + #[inline] + pub fn src_set(mut self, src_set: DescriptorSet) -> Self { + self.inner.src_set = src_set; + self + } + #[inline] + pub fn src_binding(mut self, src_binding: u32) -> Self { + self.inner.src_binding = src_binding; + self + } + #[inline] + pub fn src_array_element(mut self, src_array_element: u32) -> Self { + self.inner.src_array_element = src_array_element; + self + } + #[inline] + pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self { + self.inner.dst_set = dst_set; + self + } + #[inline] + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.inner.dst_binding = dst_binding; + self + } + #[inline] + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.inner.dst_array_element = dst_array_element; + self + } + #[inline] + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.inner.descriptor_count = descriptor_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyDescriptorSet { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferCreateFlags, + pub size: DeviceSize, + pub usage: BufferUsageFlags, + pub sharing_mode: SharingMode, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, +} +impl ::std::default::Default for BufferCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: BufferCreateFlags::default(), + size: DeviceSize::default(), + usage: BufferUsageFlags::default(), + sharing_mode: SharingMode::default(), + queue_family_index_count: u32::default(), + p_queue_family_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BufferCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CREATE_INFO; +} +impl BufferCreateInfo { + pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> { + BufferCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCreateInfoBuilder<'a> { + inner: BufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferCreateInfo {} +impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> { + type Target = BufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: BufferCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { + self.inner.sharing_mode = sharing_mode; + self + } + #[inline] + pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { + self.inner.queue_family_index_count = queue_family_indices.len() as _; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferViewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferViewCreateFlags, + pub buffer: Buffer, + pub format: Format, + pub offset: DeviceSize, + pub range: DeviceSize, +} +impl ::std::default::Default for BufferViewCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: BufferViewCreateFlags::default(), + buffer: Buffer::default(), + format: Format::default(), + offset: DeviceSize::default(), + range: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BufferViewCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_VIEW_CREATE_INFO; +} +impl BufferViewCreateInfo { + pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> { + BufferViewCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferViewCreateInfoBuilder<'a> { + inner: BufferViewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferViewCreateInfo {} +impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> { + type Target = BufferViewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferViewCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: BufferViewCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn range(mut self, range: DeviceSize) -> Self { + self.inner.range = range; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferViewCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageSubresource { + pub aspect_mask: ImageAspectFlags, + pub mip_level: u32, + pub array_layer: u32, +} +impl ImageSubresource { + pub fn builder<'a>() -> ImageSubresourceBuilder<'a> { + ImageSubresourceBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresourceBuilder<'a> { + inner: ImageSubresource, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> { + type Target = ImageSubresource; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresourceBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn mip_level(mut self, mip_level: u32) -> Self { + self.inner.mip_level = mip_level; + self + } + #[inline] + pub fn array_layer(mut self, array_layer: u32) -> Self { + self.inner.array_layer = array_layer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresource { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageSubresourceLayers { + pub aspect_mask: ImageAspectFlags, + pub mip_level: u32, + pub base_array_layer: u32, + pub layer_count: u32, +} +impl ImageSubresourceLayers { + pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> { + ImageSubresourceLayersBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresourceLayersBuilder<'a> { + inner: ImageSubresourceLayers, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> { + type Target = ImageSubresourceLayers; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresourceLayersBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn mip_level(mut self, mip_level: u32) -> Self { + self.inner.mip_level = mip_level; + self + } + #[inline] + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.inner.base_array_layer = base_array_layer; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresourceLayers { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageSubresourceRange { + pub aspect_mask: ImageAspectFlags, + pub base_mip_level: u32, + pub level_count: u32, + pub base_array_layer: u32, + pub layer_count: u32, +} +impl ImageSubresourceRange { + pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> { + ImageSubresourceRangeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresourceRangeBuilder<'a> { + inner: ImageSubresourceRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> { + type Target = ImageSubresourceRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresourceRangeBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn base_mip_level(mut self, base_mip_level: u32) -> Self { + self.inner.base_mip_level = base_mip_level; + self + } + #[inline] + pub fn level_count(mut self, level_count: u32) -> Self { + self.inner.level_count = level_count; + self + } + #[inline] + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.inner.base_array_layer = base_array_layer; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresourceRange { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, +} +impl ::std::default::Default for MemoryBarrier { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryBarrier { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_BARRIER; +} +impl MemoryBarrier { + pub fn builder<'a>() -> MemoryBarrierBuilder<'a> { + MemoryBarrierBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryBarrierBuilder<'a> { + inner: MemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> { + type Target = MemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryBarrierBuilder<'a> { + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryBarrier { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferMemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for BufferMemoryBarrier { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BufferMemoryBarrier { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER; +} +impl BufferMemoryBarrier { + pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> { + BufferMemoryBarrierBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferMemoryBarrierBuilder<'a> { + inner: BufferMemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> { + type Target = BufferMemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferMemoryBarrierBuilder<'a> { + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + #[inline] + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferMemoryBarrier { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageMemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub old_layout: ImageLayout, + pub new_layout: ImageLayout, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, + pub image: Image, + pub subresource_range: ImageSubresourceRange, +} +impl ::std::default::Default for ImageMemoryBarrier { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + old_layout: ImageLayout::default(), + new_layout: ImageLayout::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), + image: Image::default(), + subresource_range: ImageSubresourceRange::default(), + } + } +} +unsafe impl TaggedStructure for ImageMemoryBarrier { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_BARRIER; +} +impl ImageMemoryBarrier { + pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> { + ImageMemoryBarrierBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageMemoryBarrierBuilder<'a> { + inner: ImageMemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageMemoryBarrier {} +impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> { + type Target = ImageMemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageMemoryBarrierBuilder<'a> { + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn old_layout(mut self, old_layout: ImageLayout) -> Self { + self.inner.old_layout = old_layout; + self + } + #[inline] + pub fn new_layout(mut self, new_layout: ImageLayout) -> Self { + self.inner.new_layout = new_layout; + self + } + #[inline] + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + #[inline] + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { + self.inner.subresource_range = subresource_range; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageMemoryBarrier { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageCreateFlags, + pub image_type: ImageType, + pub format: Format, + pub extent: Extent3D, + pub mip_levels: u32, + pub array_layers: u32, + pub samples: SampleCountFlags, + pub tiling: ImageTiling, + pub usage: ImageUsageFlags, + pub sharing_mode: SharingMode, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, + pub initial_layout: ImageLayout, +} +impl ::std::default::Default for ImageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImageCreateFlags::default(), + image_type: ImageType::default(), + format: Format::default(), + extent: Extent3D::default(), + mip_levels: u32::default(), + array_layers: u32::default(), + samples: SampleCountFlags::default(), + tiling: ImageTiling::default(), + usage: ImageUsageFlags::default(), + sharing_mode: SharingMode::default(), + queue_family_index_count: u32::default(), + p_queue_family_indices: ::std::ptr::null(), + initial_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for ImageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CREATE_INFO; +} +impl ImageCreateInfo { + pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> { + ImageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCreateInfoBuilder<'a> { + inner: ImageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageCreateInfo {} +impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> { + type Target = ImageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn image_type(mut self, image_type: ImageType) -> Self { + self.inner.image_type = image_type; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[inline] + pub fn mip_levels(mut self, mip_levels: u32) -> Self { + self.inner.mip_levels = mip_levels; + self + } + #[inline] + pub fn array_layers(mut self, array_layers: u32) -> Self { + self.inner.array_layers = array_layers; + self + } + #[inline] + pub fn samples(mut self, samples: SampleCountFlags) -> Self { + self.inner.samples = samples; + self + } + #[inline] + pub fn tiling(mut self, tiling: ImageTiling) -> Self { + self.inner.tiling = tiling; + self + } + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { + self.inner.sharing_mode = sharing_mode; + self + } + #[inline] + pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { + self.inner.queue_family_index_count = queue_family_indices.len() as _; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + #[inline] + pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { + self.inner.initial_layout = initial_layout; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SubresourceLayout { + pub offset: DeviceSize, + pub size: DeviceSize, + pub row_pitch: DeviceSize, + pub array_pitch: DeviceSize, + pub depth_pitch: DeviceSize, +} +impl SubresourceLayout { + pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> { + SubresourceLayoutBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubresourceLayoutBuilder<'a> { + inner: SubresourceLayout, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> { + type Target = SubresourceLayout; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubresourceLayoutBuilder<'a> { + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn row_pitch(mut self, row_pitch: DeviceSize) -> Self { + self.inner.row_pitch = row_pitch; + self + } + #[inline] + pub fn array_pitch(mut self, array_pitch: DeviceSize) -> Self { + self.inner.array_pitch = array_pitch; + self + } + #[inline] + pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> Self { + self.inner.depth_pitch = depth_pitch; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubresourceLayout { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageViewCreateFlags, + pub image: Image, + pub view_type: ImageViewType, + pub format: Format, + pub components: ComponentMapping, + pub subresource_range: ImageSubresourceRange, +} +impl ::std::default::Default for ImageViewCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImageViewCreateFlags::default(), + image: Image::default(), + view_type: ImageViewType::default(), + format: Format::default(), + components: ComponentMapping::default(), + subresource_range: ImageSubresourceRange::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_CREATE_INFO; +} +impl ImageViewCreateInfo { + pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> { + ImageViewCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewCreateInfoBuilder<'a> { + inner: ImageViewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageViewCreateInfo {} +impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> { + type Target = ImageViewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageViewCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn view_type(mut self, view_type: ImageViewType) -> Self { + self.inner.view_type = view_type; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn components(mut self, components: ComponentMapping) -> Self { + self.inner.components = components; + self + } + #[inline] + pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { + self.inner.subresource_range = subresource_range; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BufferCopy { + pub src_offset: DeviceSize, + pub dst_offset: DeviceSize, + pub size: DeviceSize, +} +impl BufferCopy { + pub fn builder<'a>() -> BufferCopyBuilder<'a> { + BufferCopyBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCopyBuilder<'a> { + inner: BufferCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> { + type Target = BufferCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCopyBuilder<'a> { + #[inline] + pub fn src_offset(mut self, src_offset: DeviceSize) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCopy { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SparseMemoryBind { + pub resource_offset: DeviceSize, + pub size: DeviceSize, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub flags: SparseMemoryBindFlags, +} +impl SparseMemoryBind { + pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> { + SparseMemoryBindBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseMemoryBindBuilder<'a> { + inner: SparseMemoryBind, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> { + type Target = SparseMemoryBind; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseMemoryBindBuilder<'a> { + #[inline] + pub fn resource_offset(mut self, resource_offset: DeviceSize) -> Self { + self.inner.resource_offset = resource_offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[inline] + pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseMemoryBind { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SparseImageMemoryBind { + pub subresource: ImageSubresource, + pub offset: Offset3D, + pub extent: Extent3D, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub flags: SparseMemoryBindFlags, +} +impl SparseImageMemoryBind { + pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> { + SparseImageMemoryBindBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageMemoryBindBuilder<'a> { + inner: SparseImageMemoryBind, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> { + type Target = SparseImageMemoryBind; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageMemoryBindBuilder<'a> { + #[inline] + pub fn subresource(mut self, subresource: ImageSubresource) -> Self { + self.inner.subresource = subresource; + self + } + #[inline] + pub fn offset(mut self, offset: Offset3D) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[inline] + pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageMemoryBind { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseBufferMemoryBindInfo { + pub buffer: Buffer, + pub bind_count: u32, + pub p_binds: *const SparseMemoryBind, +} +impl ::std::default::Default for SparseBufferMemoryBindInfo { + #[inline] + fn default() -> Self { + Self { + buffer: Buffer::default(), + bind_count: u32::default(), + p_binds: ::std::ptr::null(), + } + } +} +impl SparseBufferMemoryBindInfo { + pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> { + SparseBufferMemoryBindInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseBufferMemoryBindInfoBuilder<'a> { + inner: SparseBufferMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> { + type Target = SparseBufferMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseBufferMemoryBindInfoBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self { + self.inner.bind_count = binds.len() as _; + self.inner.p_binds = binds.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseBufferMemoryBindInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseImageOpaqueMemoryBindInfo { + pub image: Image, + pub bind_count: u32, + pub p_binds: *const SparseMemoryBind, +} +impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo { + #[inline] + fn default() -> Self { + Self { + image: Image::default(), + bind_count: u32::default(), + p_binds: ::std::ptr::null(), + } + } +} +impl SparseImageOpaqueMemoryBindInfo { + pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + SparseImageOpaqueMemoryBindInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> { + inner: SparseImageOpaqueMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> { + type Target = SparseImageOpaqueMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self { + self.inner.bind_count = binds.len() as _; + self.inner.p_binds = binds.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageOpaqueMemoryBindInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseImageMemoryBindInfo { + pub image: Image, + pub bind_count: u32, + pub p_binds: *const SparseImageMemoryBind, +} +impl ::std::default::Default for SparseImageMemoryBindInfo { + #[inline] + fn default() -> Self { + Self { + image: Image::default(), + bind_count: u32::default(), + p_binds: ::std::ptr::null(), + } + } +} +impl SparseImageMemoryBindInfo { + pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> { + SparseImageMemoryBindInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageMemoryBindInfoBuilder<'a> { + inner: SparseImageMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> { + type Target = SparseImageMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageMemoryBindInfoBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn binds(mut self, binds: &'a [SparseImageMemoryBind]) -> Self { + self.inner.bind_count = binds.len() as _; + self.inner.p_binds = binds.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageMemoryBindInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindSparseInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: u32, + pub p_wait_semaphores: *const Semaphore, + pub buffer_bind_count: u32, + pub p_buffer_binds: *const SparseBufferMemoryBindInfo, + pub image_opaque_bind_count: u32, + pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo, + pub image_bind_count: u32, + pub p_image_binds: *const SparseImageMemoryBindInfo, + pub signal_semaphore_count: u32, + pub p_signal_semaphores: *const Semaphore, +} +impl ::std::default::Default for BindSparseInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_count: u32::default(), + p_wait_semaphores: ::std::ptr::null(), + buffer_bind_count: u32::default(), + p_buffer_binds: ::std::ptr::null(), + image_opaque_bind_count: u32::default(), + p_image_opaque_binds: ::std::ptr::null(), + image_bind_count: u32::default(), + p_image_binds: ::std::ptr::null(), + signal_semaphore_count: u32::default(), + p_signal_semaphores: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BindSparseInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_SPARSE_INFO; +} +impl BindSparseInfo { + pub fn builder<'a>() -> BindSparseInfoBuilder<'a> { + BindSparseInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindSparseInfoBuilder<'a> { + inner: BindSparseInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBindSparseInfo {} +impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> { + type Target = BindSparseInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindSparseInfoBuilder<'a> { + #[inline] + pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { + self.inner.wait_semaphore_count = wait_semaphores.len() as _; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + #[inline] + pub fn buffer_binds(mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo]) -> Self { + self.inner.buffer_bind_count = buffer_binds.len() as _; + self.inner.p_buffer_binds = buffer_binds.as_ptr(); + self + } + #[inline] + pub fn image_opaque_binds( + mut self, + image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo], + ) -> Self { + self.inner.image_opaque_bind_count = image_opaque_binds.len() as _; + self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr(); + self + } + #[inline] + pub fn image_binds(mut self, image_binds: &'a [SparseImageMemoryBindInfo]) -> Self { + self.inner.image_bind_count = image_binds.len() as _; + self.inner.p_image_binds = image_binds.as_ptr(); + self + } + #[inline] + pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self { + self.inner.signal_semaphore_count = signal_semaphores.len() as _; + self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindSparseInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageCopy { + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ImageCopy { + pub fn builder<'a>() -> ImageCopyBuilder<'a> { + ImageCopyBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCopyBuilder<'a> { + inner: ImageCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> { + type Target = ImageCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCopyBuilder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offset(mut self, src_offset: Offset3D) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCopy { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageBlit { + pub src_subresource: ImageSubresourceLayers, + pub src_offsets: [Offset3D; 2], + pub dst_subresource: ImageSubresourceLayers, + pub dst_offsets: [Offset3D; 2], +} +impl ::std::default::Default for ImageBlit { + #[inline] + fn default() -> Self { + Self { + src_subresource: ImageSubresourceLayers::default(), + src_offsets: unsafe { ::std::mem::zeroed() }, + dst_subresource: ImageSubresourceLayers::default(), + dst_offsets: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ImageBlit { + pub fn builder<'a>() -> ImageBlitBuilder<'a> { + ImageBlitBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageBlitBuilder<'a> { + inner: ImageBlit, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> { + type Target = ImageBlit; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageBlitBuilder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self { + self.inner.src_offsets = src_offsets; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self { + self.inner.dst_offsets = dst_offsets; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageBlit { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BufferImageCopy { + pub buffer_offset: DeviceSize, + pub buffer_row_length: u32, + pub buffer_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +impl BufferImageCopy { + pub fn builder<'a>() -> BufferImageCopyBuilder<'a> { + BufferImageCopyBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferImageCopyBuilder<'a> { + inner: BufferImageCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> { + type Target = BufferImageCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferImageCopyBuilder<'a> { + #[inline] + pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self { + self.inner.buffer_offset = buffer_offset; + self + } + #[inline] + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.inner.buffer_row_length = buffer_row_length; + self + } + #[inline] + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.inner.buffer_image_height = buffer_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.inner.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferImageCopy { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct CopyMemoryIndirectCommandNV { + pub src_address: DeviceAddress, + pub dst_address: DeviceAddress, + pub size: DeviceSize, +} +impl CopyMemoryIndirectCommandNV { + pub fn builder<'a>() -> CopyMemoryIndirectCommandNVBuilder<'a> { + CopyMemoryIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMemoryIndirectCommandNVBuilder<'a> { + inner: CopyMemoryIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMemoryIndirectCommandNVBuilder<'a> { + type Target = CopyMemoryIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMemoryIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMemoryIndirectCommandNVBuilder<'a> { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.inner.src_address = src_address; + self + } + #[inline] + pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self { + self.inner.dst_address = dst_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMemoryIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct CopyMemoryToImageIndirectCommandNV { + pub src_address: DeviceAddress, + pub buffer_row_length: u32, + pub buffer_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +impl CopyMemoryToImageIndirectCommandNV { + pub fn builder<'a>() -> CopyMemoryToImageIndirectCommandNVBuilder<'a> { + CopyMemoryToImageIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMemoryToImageIndirectCommandNVBuilder<'a> { + inner: CopyMemoryToImageIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMemoryToImageIndirectCommandNVBuilder<'a> { + type Target = CopyMemoryToImageIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMemoryToImageIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMemoryToImageIndirectCommandNVBuilder<'a> { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.inner.src_address = src_address; + self + } + #[inline] + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.inner.buffer_row_length = buffer_row_length; + self + } + #[inline] + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.inner.buffer_image_height = buffer_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.inner.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMemoryToImageIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageResolve { + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ImageResolve { + pub fn builder<'a>() -> ImageResolveBuilder<'a> { + ImageResolveBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageResolveBuilder<'a> { + inner: ImageResolve, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> { + type Target = ImageResolve; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageResolveBuilder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offset(mut self, src_offset: Offset3D) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageResolve { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderModuleCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ShaderModuleCreateFlags, + pub code_size: usize, + pub p_code: *const u32, +} +impl ::std::default::Default for ShaderModuleCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ShaderModuleCreateFlags::default(), + code_size: usize::default(), + p_code: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ShaderModuleCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_CREATE_INFO; +} +impl ShaderModuleCreateInfo { + pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> { + ShaderModuleCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderModuleCreateInfoBuilder<'a> { + inner: ShaderModuleCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfoBuilder<'_> {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfo {} +pub unsafe trait ExtendsShaderModuleCreateInfo {} +impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> { + type Target = ShaderModuleCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderModuleCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn code(mut self, code: &'a [u32]) -> Self { + self.inner.code_size = code.len() * 4; + self.inner.p_code = code.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderModuleCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutBinding { + pub binding: u32, + pub descriptor_type: DescriptorType, + pub descriptor_count: u32, + pub stage_flags: ShaderStageFlags, + pub p_immutable_samplers: *const Sampler, +} +impl ::std::default::Default for DescriptorSetLayoutBinding { + #[inline] + fn default() -> Self { + Self { + binding: u32::default(), + descriptor_type: DescriptorType::default(), + descriptor_count: u32::default(), + stage_flags: ShaderStageFlags::default(), + p_immutable_samplers: ::std::ptr::null(), + } + } +} +impl DescriptorSetLayoutBinding { + pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> { + DescriptorSetLayoutBindingBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutBindingBuilder<'a> { + inner: DescriptorSetLayoutBinding, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> { + type Target = DescriptorSetLayoutBinding; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutBindingBuilder<'a> { + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { + self.inner.descriptor_type = descriptor_type; + self + } + #[inline] + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.inner.descriptor_count = descriptor_count; + self + } + #[inline] + pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self { + self.inner.stage_flags = stage_flags; + self + } + #[inline] + pub fn immutable_samplers(mut self, immutable_samplers: &'a [Sampler]) -> Self { + self.inner.descriptor_count = immutable_samplers.len() as _; + self.inner.p_immutable_samplers = immutable_samplers.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutBinding { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorSetLayoutCreateFlags, + pub binding_count: u32, + pub p_bindings: *const DescriptorSetLayoutBinding, +} +impl ::std::default::Default for DescriptorSetLayoutCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DescriptorSetLayoutCreateFlags::default(), + binding_count: u32::default(), + p_bindings: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetLayoutCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO; +} +impl DescriptorSetLayoutCreateInfo { + pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> { + DescriptorSetLayoutCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutCreateInfoBuilder<'a> { + inner: DescriptorSetLayoutCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> { + type Target = DescriptorSetLayoutCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DescriptorSetLayoutCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn bindings(mut self, bindings: &'a [DescriptorSetLayoutBinding]) -> Self { + self.inner.binding_count = bindings.len() as _; + self.inner.p_bindings = bindings.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DescriptorPoolSize { + pub ty: DescriptorType, + pub descriptor_count: u32, +} +impl DescriptorPoolSize { + pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> { + DescriptorPoolSizeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorPoolSizeBuilder<'a> { + inner: DescriptorPoolSize, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> { + type Target = DescriptorPoolSize; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorPoolSizeBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: DescriptorType) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.inner.descriptor_count = descriptor_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorPoolSize { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorPoolCreateFlags, + pub max_sets: u32, + pub pool_size_count: u32, + pub p_pool_sizes: *const DescriptorPoolSize, +} +impl ::std::default::Default for DescriptorPoolCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DescriptorPoolCreateFlags::default(), + max_sets: u32::default(), + pool_size_count: u32::default(), + p_pool_sizes: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorPoolCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_POOL_CREATE_INFO; +} +impl DescriptorPoolCreateInfo { + pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> { + DescriptorPoolCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorPoolCreateInfoBuilder<'a> { + inner: DescriptorPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorPoolCreateInfo {} +impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> { + type Target = DescriptorPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorPoolCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DescriptorPoolCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn max_sets(mut self, max_sets: u32) -> Self { + self.inner.max_sets = max_sets; + self + } + #[inline] + pub fn pool_sizes(mut self, pool_sizes: &'a [DescriptorPoolSize]) -> Self { + self.inner.pool_size_count = pool_sizes.len() as _; + self.inner.p_pool_sizes = pool_sizes.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorPoolCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_pool: DescriptorPool, + pub descriptor_set_count: u32, + pub p_set_layouts: *const DescriptorSetLayout, +} +impl ::std::default::Default for DescriptorSetAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + descriptor_pool: DescriptorPool::default(), + descriptor_set_count: u32::default(), + p_set_layouts: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_ALLOCATE_INFO; +} +impl DescriptorSetAllocateInfo { + pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> { + DescriptorSetAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetAllocateInfoBuilder<'a> { + inner: DescriptorSetAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorSetAllocateInfo {} +impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> { + type Target = DescriptorSetAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetAllocateInfoBuilder<'a> { + #[inline] + pub fn descriptor_pool(mut self, descriptor_pool: DescriptorPool) -> Self { + self.inner.descriptor_pool = descriptor_pool; + self + } + #[inline] + pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self { + self.inner.descriptor_set_count = set_layouts.len() as _; + self.inner.p_set_layouts = set_layouts.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SpecializationMapEntry { + pub constant_id: u32, + pub offset: u32, + pub size: usize, +} +impl SpecializationMapEntry { + pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> { + SpecializationMapEntryBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SpecializationMapEntryBuilder<'a> { + inner: SpecializationMapEntry, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> { + type Target = SpecializationMapEntry; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SpecializationMapEntryBuilder<'a> { + #[inline] + pub fn constant_id(mut self, constant_id: u32) -> Self { + self.inner.constant_id = constant_id; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: usize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SpecializationMapEntry { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SpecializationInfo { + pub map_entry_count: u32, + pub p_map_entries: *const SpecializationMapEntry, + pub data_size: usize, + pub p_data: *const c_void, +} +impl ::std::default::Default for SpecializationInfo { + #[inline] + fn default() -> Self { + Self { + map_entry_count: u32::default(), + p_map_entries: ::std::ptr::null(), + data_size: usize::default(), + p_data: ::std::ptr::null(), + } + } +} +impl SpecializationInfo { + pub fn builder<'a>() -> SpecializationInfoBuilder<'a> { + SpecializationInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SpecializationInfoBuilder<'a> { + inner: SpecializationInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> { + type Target = SpecializationInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SpecializationInfoBuilder<'a> { + #[inline] + pub fn map_entries(mut self, map_entries: &'a [SpecializationMapEntry]) -> Self { + self.inner.map_entry_count = map_entries.len() as _; + self.inner.p_map_entries = map_entries.as_ptr(); + self + } + #[inline] + pub fn data(mut self, data: &'a [u8]) -> Self { + self.inner.data_size = data.len(); + self.inner.p_data = data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SpecializationInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineShaderStageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineShaderStageCreateFlags, + pub stage: ShaderStageFlags, + pub module: ShaderModule, + pub p_name: *const c_char, + pub p_specialization_info: *const SpecializationInfo, +} +impl ::std::default::Default for PipelineShaderStageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineShaderStageCreateFlags::default(), + stage: ShaderStageFlags::default(), + module: ShaderModule::default(), + p_name: ::std::ptr::null(), + p_specialization_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineShaderStageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO; +} +impl PipelineShaderStageCreateInfo { + pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> { + PipelineShaderStageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineShaderStageCreateInfoBuilder<'a> { + inner: PipelineShaderStageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineShaderStageCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> { + type Target = PipelineShaderStageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineShaderStageCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stage(mut self, stage: ShaderStageFlags) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn module(mut self, module: ShaderModule) -> Self { + self.inner.module = module; + self + } + #[inline] + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_name = name.as_ptr(); + self + } + #[inline] + pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self { + self.inner.p_specialization_info = specialization_info; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineShaderStageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ComputePipelineCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage: PipelineShaderStageCreateInfo, + pub layout: PipelineLayout, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, +} +impl ::std::default::Default for ComputePipelineCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage: PipelineShaderStageCreateInfo::default(), + layout: PipelineLayout::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + } + } +} +unsafe impl TaggedStructure for ComputePipelineCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMPUTE_PIPELINE_CREATE_INFO; +} +impl ComputePipelineCreateInfo { + pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> { + ComputePipelineCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ComputePipelineCreateInfoBuilder<'a> { + inner: ComputePipelineCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsComputePipelineCreateInfo {} +impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> { + type Target = ComputePipelineCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ComputePipelineCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stage(mut self, stage: PipelineShaderStageCreateInfo) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ComputePipelineCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VertexInputBindingDescription { + pub binding: u32, + pub stride: u32, + pub input_rate: VertexInputRate, +} +impl VertexInputBindingDescription { + pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> { + VertexInputBindingDescriptionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputBindingDescriptionBuilder<'a> { + inner: VertexInputBindingDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> { + type Target = VertexInputBindingDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputBindingDescriptionBuilder<'a> { + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn stride(mut self, stride: u32) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self { + self.inner.input_rate = input_rate; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputBindingDescription { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VertexInputAttributeDescription { + pub location: u32, + pub binding: u32, + pub format: Format, + pub offset: u32, +} +impl VertexInputAttributeDescription { + pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> { + VertexInputAttributeDescriptionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputAttributeDescriptionBuilder<'a> { + inner: VertexInputAttributeDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> { + type Target = VertexInputAttributeDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputAttributeDescriptionBuilder<'a> { + #[inline] + pub fn location(mut self, location: u32) -> Self { + self.inner.location = location; + self + } + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputAttributeDescription { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineVertexInputStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineVertexInputStateCreateFlags, + pub vertex_binding_description_count: u32, + pub p_vertex_binding_descriptions: *const VertexInputBindingDescription, + pub vertex_attribute_description_count: u32, + pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription, +} +impl ::std::default::Default for PipelineVertexInputStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineVertexInputStateCreateFlags::default(), + vertex_binding_description_count: u32::default(), + p_vertex_binding_descriptions: ::std::ptr::null(), + vertex_attribute_description_count: u32::default(), + p_vertex_attribute_descriptions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineVertexInputStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; +} +impl PipelineVertexInputStateCreateInfo { + pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> { + PipelineVertexInputStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineVertexInputStateCreateInfoBuilder<'a> { + inner: PipelineVertexInputStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> { + type Target = PipelineVertexInputStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineVertexInputStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn vertex_binding_descriptions( + mut self, + vertex_binding_descriptions: &'a [VertexInputBindingDescription], + ) -> Self { + self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as _; + self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr(); + self + } + #[inline] + pub fn vertex_attribute_descriptions( + mut self, + vertex_attribute_descriptions: &'a [VertexInputAttributeDescription], + ) -> Self { + self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _; + self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineVertexInputStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineInputAssemblyStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineInputAssemblyStateCreateFlags, + pub topology: PrimitiveTopology, + pub primitive_restart_enable: Bool32, +} +impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineInputAssemblyStateCreateFlags::default(), + topology: PrimitiveTopology::default(), + primitive_restart_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineInputAssemblyStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; +} +impl PipelineInputAssemblyStateCreateInfo { + pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + PipelineInputAssemblyStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> { + inner: PipelineInputAssemblyStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> { + type Target = PipelineInputAssemblyStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineInputAssemblyStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn topology(mut self, topology: PrimitiveTopology) -> Self { + self.inner.topology = topology; + self + } + #[inline] + pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self { + self.inner.primitive_restart_enable = primitive_restart_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineInputAssemblyStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineTessellationStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineTessellationStateCreateFlags, + pub patch_control_points: u32, +} +impl ::std::default::Default for PipelineTessellationStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineTessellationStateCreateFlags::default(), + patch_control_points: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineTessellationStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO; +} +impl PipelineTessellationStateCreateInfo { + pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> { + PipelineTessellationStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineTessellationStateCreateInfoBuilder<'a> { + inner: PipelineTessellationStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> { + type Target = PipelineTessellationStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineTessellationStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn patch_control_points(mut self, patch_control_points: u32) -> Self { + self.inner.patch_control_points = patch_control_points; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineTessellationStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineViewportStateCreateFlags, + pub viewport_count: u32, + pub p_viewports: *const Viewport, + pub scissor_count: u32, + pub p_scissors: *const Rect2D, +} +impl ::std::default::Default for PipelineViewportStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineViewportStateCreateFlags::default(), + viewport_count: u32::default(), + p_viewports: ::std::ptr::null(), + scissor_count: u32::default(), + p_scissors: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO; +} +impl PipelineViewportStateCreateInfo { + pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> { + PipelineViewportStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportStateCreateInfoBuilder<'a> { + inner: PipelineViewportStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineViewportStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> { + type Target = PipelineViewportStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineViewportStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn viewport_count(mut self, viewport_count: u32) -> Self { + self.inner.viewport_count = viewport_count; + self + } + #[inline] + pub fn viewports(mut self, viewports: &'a [Viewport]) -> Self { + self.inner.viewport_count = viewports.len() as _; + self.inner.p_viewports = viewports.as_ptr(); + self + } + #[inline] + pub fn scissor_count(mut self, scissor_count: u32) -> Self { + self.inner.scissor_count = scissor_count; + self + } + #[inline] + pub fn scissors(mut self, scissors: &'a [Rect2D]) -> Self { + self.inner.scissor_count = scissors.len() as _; + self.inner.p_scissors = scissors.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationStateCreateFlags, + pub depth_clamp_enable: Bool32, + pub rasterizer_discard_enable: Bool32, + pub polygon_mode: PolygonMode, + pub cull_mode: CullModeFlags, + pub front_face: FrontFace, + pub depth_bias_enable: Bool32, + pub depth_bias_constant_factor: f32, + pub depth_bias_clamp: f32, + pub depth_bias_slope_factor: f32, + pub line_width: f32, +} +impl ::std::default::Default for PipelineRasterizationStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineRasterizationStateCreateFlags::default(), + depth_clamp_enable: Bool32::default(), + rasterizer_discard_enable: Bool32::default(), + polygon_mode: PolygonMode::default(), + cull_mode: CullModeFlags::default(), + front_face: FrontFace::default(), + depth_bias_enable: Bool32::default(), + depth_bias_constant_factor: f32::default(), + depth_bias_clamp: f32::default(), + depth_bias_slope_factor: f32::default(), + line_width: f32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO; +} +impl PipelineRasterizationStateCreateInfo { + pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> { + PipelineRasterizationStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationStateCreateInfoBuilder<'a> { + inner: PipelineRasterizationStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> { + type Target = PipelineRasterizationStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineRasterizationStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self { + self.inner.depth_clamp_enable = depth_clamp_enable.into(); + self + } + #[inline] + pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self { + self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into(); + self + } + #[inline] + pub fn polygon_mode(mut self, polygon_mode: PolygonMode) -> Self { + self.inner.polygon_mode = polygon_mode; + self + } + #[inline] + pub fn cull_mode(mut self, cull_mode: CullModeFlags) -> Self { + self.inner.cull_mode = cull_mode; + self + } + #[inline] + pub fn front_face(mut self, front_face: FrontFace) -> Self { + self.inner.front_face = front_face; + self + } + #[inline] + pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self { + self.inner.depth_bias_enable = depth_bias_enable.into(); + self + } + #[inline] + pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self { + self.inner.depth_bias_constant_factor = depth_bias_constant_factor; + self + } + #[inline] + pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self { + self.inner.depth_bias_clamp = depth_bias_clamp; + self + } + #[inline] + pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self { + self.inner.depth_bias_slope_factor = depth_bias_slope_factor; + self + } + #[inline] + pub fn line_width(mut self, line_width: f32) -> Self { + self.inner.line_width = line_width; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineMultisampleStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineMultisampleStateCreateFlags, + pub rasterization_samples: SampleCountFlags, + pub sample_shading_enable: Bool32, + pub min_sample_shading: f32, + pub p_sample_mask: *const SampleMask, + pub alpha_to_coverage_enable: Bool32, + pub alpha_to_one_enable: Bool32, +} +impl ::std::default::Default for PipelineMultisampleStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineMultisampleStateCreateFlags::default(), + rasterization_samples: SampleCountFlags::default(), + sample_shading_enable: Bool32::default(), + min_sample_shading: f32::default(), + p_sample_mask: ::std::ptr::null(), + alpha_to_coverage_enable: Bool32::default(), + alpha_to_one_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineMultisampleStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; +} +impl PipelineMultisampleStateCreateInfo { + pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> { + PipelineMultisampleStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineMultisampleStateCreateInfoBuilder<'a> { + inner: PipelineMultisampleStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> { + type Target = PipelineMultisampleStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineMultisampleStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[inline] + pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self { + self.inner.sample_shading_enable = sample_shading_enable.into(); + self + } + #[inline] + pub fn min_sample_shading(mut self, min_sample_shading: f32) -> Self { + self.inner.min_sample_shading = min_sample_shading; + self + } + #[doc = r" Sets `p_sample_mask` to `null` if the slice is empty. The mask will"] + #[doc = r" be treated as if it has all bits set to `1`."] + #[doc = r""] + #[doc = r" See "] + #[doc = r" for more details."] + #[inline] + pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self { + self.inner.p_sample_mask = if sample_mask.is_empty() { + std::ptr::null() + } else { + sample_mask.as_ptr() + }; + self + } + #[inline] + pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self { + self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into(); + self + } + #[inline] + pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self { + self.inner.alpha_to_one_enable = alpha_to_one_enable.into(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineMultisampleStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PipelineColorBlendAttachmentState { + pub blend_enable: Bool32, + pub src_color_blend_factor: BlendFactor, + pub dst_color_blend_factor: BlendFactor, + pub color_blend_op: BlendOp, + pub src_alpha_blend_factor: BlendFactor, + pub dst_alpha_blend_factor: BlendFactor, + pub alpha_blend_op: BlendOp, + pub color_write_mask: ColorComponentFlags, +} +impl PipelineColorBlendAttachmentState { + pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> { + PipelineColorBlendAttachmentStateBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineColorBlendAttachmentStateBuilder<'a> { + inner: PipelineColorBlendAttachmentState, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> { + type Target = PipelineColorBlendAttachmentState; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> { + #[inline] + pub fn blend_enable(mut self, blend_enable: bool) -> Self { + self.inner.blend_enable = blend_enable.into(); + self + } + #[inline] + pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self { + self.inner.src_color_blend_factor = src_color_blend_factor; + self + } + #[inline] + pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self { + self.inner.dst_color_blend_factor = dst_color_blend_factor; + self + } + #[inline] + pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self { + self.inner.color_blend_op = color_blend_op; + self + } + #[inline] + pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self { + self.inner.src_alpha_blend_factor = src_alpha_blend_factor; + self + } + #[inline] + pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self { + self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor; + self + } + #[inline] + pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self { + self.inner.alpha_blend_op = alpha_blend_op; + self + } + #[inline] + pub fn color_write_mask(mut self, color_write_mask: ColorComponentFlags) -> Self { + self.inner.color_write_mask = color_write_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineColorBlendAttachmentState { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineColorBlendStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineColorBlendStateCreateFlags, + pub logic_op_enable: Bool32, + pub logic_op: LogicOp, + pub attachment_count: u32, + pub p_attachments: *const PipelineColorBlendAttachmentState, + pub blend_constants: [f32; 4], +} +impl ::std::default::Default for PipelineColorBlendStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineColorBlendStateCreateFlags::default(), + logic_op_enable: Bool32::default(), + logic_op: LogicOp::default(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + blend_constants: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PipelineColorBlendStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; +} +impl PipelineColorBlendStateCreateInfo { + pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> { + PipelineColorBlendStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineColorBlendStateCreateInfoBuilder<'a> { + inner: PipelineColorBlendStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> { + type Target = PipelineColorBlendStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineColorBlendStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self { + self.inner.logic_op_enable = logic_op_enable.into(); + self + } + #[inline] + pub fn logic_op(mut self, logic_op: LogicOp) -> Self { + self.inner.logic_op = logic_op; + self + } + #[inline] + pub fn attachments(mut self, attachments: &'a [PipelineColorBlendAttachmentState]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[inline] + pub fn blend_constants(mut self, blend_constants: [f32; 4]) -> Self { + self.inner.blend_constants = blend_constants; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineColorBlendStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineDynamicStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDynamicStateCreateFlags, + pub dynamic_state_count: u32, + pub p_dynamic_states: *const DynamicState, +} +impl ::std::default::Default for PipelineDynamicStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineDynamicStateCreateFlags::default(), + dynamic_state_count: u32::default(), + p_dynamic_states: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineDynamicStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO; +} +impl PipelineDynamicStateCreateInfo { + pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> { + PipelineDynamicStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineDynamicStateCreateInfoBuilder<'a> { + inner: PipelineDynamicStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> { + type Target = PipelineDynamicStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineDynamicStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn dynamic_states(mut self, dynamic_states: &'a [DynamicState]) -> Self { + self.inner.dynamic_state_count = dynamic_states.len() as _; + self.inner.p_dynamic_states = dynamic_states.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineDynamicStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct StencilOpState { + pub fail_op: StencilOp, + pub pass_op: StencilOp, + pub depth_fail_op: StencilOp, + pub compare_op: CompareOp, + pub compare_mask: u32, + pub write_mask: u32, + pub reference: u32, +} +impl StencilOpState { + pub fn builder<'a>() -> StencilOpStateBuilder<'a> { + StencilOpStateBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct StencilOpStateBuilder<'a> { + inner: StencilOpState, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> { + type Target = StencilOpState; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> StencilOpStateBuilder<'a> { + #[inline] + pub fn fail_op(mut self, fail_op: StencilOp) -> Self { + self.inner.fail_op = fail_op; + self + } + #[inline] + pub fn pass_op(mut self, pass_op: StencilOp) -> Self { + self.inner.pass_op = pass_op; + self + } + #[inline] + pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> Self { + self.inner.depth_fail_op = depth_fail_op; + self + } + #[inline] + pub fn compare_op(mut self, compare_op: CompareOp) -> Self { + self.inner.compare_op = compare_op; + self + } + #[inline] + pub fn compare_mask(mut self, compare_mask: u32) -> Self { + self.inner.compare_mask = compare_mask; + self + } + #[inline] + pub fn write_mask(mut self, write_mask: u32) -> Self { + self.inner.write_mask = write_mask; + self + } + #[inline] + pub fn reference(mut self, reference: u32) -> Self { + self.inner.reference = reference; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> StencilOpState { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineDepthStencilStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDepthStencilStateCreateFlags, + pub depth_test_enable: Bool32, + pub depth_write_enable: Bool32, + pub depth_compare_op: CompareOp, + pub depth_bounds_test_enable: Bool32, + pub stencil_test_enable: Bool32, + pub front: StencilOpState, + pub back: StencilOpState, + pub min_depth_bounds: f32, + pub max_depth_bounds: f32, +} +impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineDepthStencilStateCreateFlags::default(), + depth_test_enable: Bool32::default(), + depth_write_enable: Bool32::default(), + depth_compare_op: CompareOp::default(), + depth_bounds_test_enable: Bool32::default(), + stencil_test_enable: Bool32::default(), + front: StencilOpState::default(), + back: StencilOpState::default(), + min_depth_bounds: f32::default(), + max_depth_bounds: f32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineDepthStencilStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; +} +impl PipelineDepthStencilStateCreateInfo { + pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + PipelineDepthStencilStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> { + inner: PipelineDepthStencilStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> { + type Target = PipelineDepthStencilStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineDepthStencilStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self { + self.inner.depth_test_enable = depth_test_enable.into(); + self + } + #[inline] + pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self { + self.inner.depth_write_enable = depth_write_enable.into(); + self + } + #[inline] + pub fn depth_compare_op(mut self, depth_compare_op: CompareOp) -> Self { + self.inner.depth_compare_op = depth_compare_op; + self + } + #[inline] + pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self { + self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into(); + self + } + #[inline] + pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self { + self.inner.stencil_test_enable = stencil_test_enable.into(); + self + } + #[inline] + pub fn front(mut self, front: StencilOpState) -> Self { + self.inner.front = front; + self + } + #[inline] + pub fn back(mut self, back: StencilOpState) -> Self { + self.inner.back = back; + self + } + #[inline] + pub fn min_depth_bounds(mut self, min_depth_bounds: f32) -> Self { + self.inner.min_depth_bounds = min_depth_bounds; + self + } + #[inline] + pub fn max_depth_bounds(mut self, max_depth_bounds: f32) -> Self { + self.inner.max_depth_bounds = max_depth_bounds; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineDepthStencilStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GraphicsPipelineCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, + pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo, + pub p_tessellation_state: *const PipelineTessellationStateCreateInfo, + pub p_viewport_state: *const PipelineViewportStateCreateInfo, + pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo, + pub p_multisample_state: *const PipelineMultisampleStateCreateInfo, + pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo, + pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo, + pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, + pub layout: PipelineLayout, + pub render_pass: RenderPass, + pub subpass: u32, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, +} +impl ::std::default::Default for GraphicsPipelineCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + p_vertex_input_state: ::std::ptr::null(), + p_input_assembly_state: ::std::ptr::null(), + p_tessellation_state: ::std::ptr::null(), + p_viewport_state: ::std::ptr::null(), + p_rasterization_state: ::std::ptr::null(), + p_multisample_state: ::std::ptr::null(), + p_depth_stencil_state: ::std::ptr::null(), + p_color_blend_state: ::std::ptr::null(), + p_dynamic_state: ::std::ptr::null(), + layout: PipelineLayout::default(), + render_pass: RenderPass::default(), + subpass: u32::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + } + } +} +unsafe impl TaggedStructure for GraphicsPipelineCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_CREATE_INFO; +} +impl GraphicsPipelineCreateInfo { + pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> { + GraphicsPipelineCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GraphicsPipelineCreateInfoBuilder<'a> { + inner: GraphicsPipelineCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsGraphicsPipelineCreateInfo {} +impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> { + type Target = GraphicsPipelineCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.inner.stage_count = stages.len() as _; + self.inner.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn vertex_input_state( + mut self, + vertex_input_state: &'a PipelineVertexInputStateCreateInfo, + ) -> Self { + self.inner.p_vertex_input_state = vertex_input_state; + self + } + #[inline] + pub fn input_assembly_state( + mut self, + input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo, + ) -> Self { + self.inner.p_input_assembly_state = input_assembly_state; + self + } + #[inline] + pub fn tessellation_state( + mut self, + tessellation_state: &'a PipelineTessellationStateCreateInfo, + ) -> Self { + self.inner.p_tessellation_state = tessellation_state; + self + } + #[inline] + pub fn viewport_state(mut self, viewport_state: &'a PipelineViewportStateCreateInfo) -> Self { + self.inner.p_viewport_state = viewport_state; + self + } + #[inline] + pub fn rasterization_state( + mut self, + rasterization_state: &'a PipelineRasterizationStateCreateInfo, + ) -> Self { + self.inner.p_rasterization_state = rasterization_state; + self + } + #[inline] + pub fn multisample_state( + mut self, + multisample_state: &'a PipelineMultisampleStateCreateInfo, + ) -> Self { + self.inner.p_multisample_state = multisample_state; + self + } + #[inline] + pub fn depth_stencil_state( + mut self, + depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo, + ) -> Self { + self.inner.p_depth_stencil_state = depth_stencil_state; + self + } + #[inline] + pub fn color_blend_state( + mut self, + color_blend_state: &'a PipelineColorBlendStateCreateInfo, + ) -> Self { + self.inner.p_color_blend_state = color_blend_state; + self + } + #[inline] + pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self { + self.inner.p_dynamic_state = dynamic_state; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn subpass(mut self, subpass: u32) -> Self { + self.inner.subpass = subpass; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GraphicsPipelineCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCacheCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCacheCreateFlags, + pub initial_data_size: usize, + pub p_initial_data: *const c_void, +} +impl ::std::default::Default for PipelineCacheCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCacheCreateFlags::default(), + initial_data_size: usize::default(), + p_initial_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineCacheCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CACHE_CREATE_INFO; +} +impl PipelineCacheCreateInfo { + pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> { + PipelineCacheCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCacheCreateInfoBuilder<'a> { + inner: PipelineCacheCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> { + type Target = PipelineCacheCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCacheCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self { + self.inner.initial_data_size = initial_data.len(); + self.inner.p_initial_data = initial_data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCacheCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCacheHeaderVersionOne { + pub header_size: u32, + pub header_version: PipelineCacheHeaderVersion, + pub vendor_id: u32, + pub device_id: u32, + pub pipeline_cache_uuid: [u8; UUID_SIZE], +} +impl ::std::default::Default for PipelineCacheHeaderVersionOne { + #[inline] + fn default() -> Self { + Self { + header_size: u32::default(), + header_version: PipelineCacheHeaderVersion::default(), + vendor_id: u32::default(), + device_id: u32::default(), + pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PipelineCacheHeaderVersionOne { + pub fn builder<'a>() -> PipelineCacheHeaderVersionOneBuilder<'a> { + PipelineCacheHeaderVersionOneBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCacheHeaderVersionOneBuilder<'a> { + inner: PipelineCacheHeaderVersionOne, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCacheHeaderVersionOneBuilder<'a> { + type Target = PipelineCacheHeaderVersionOne; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> { + #[inline] + pub fn header_size(mut self, header_size: u32) -> Self { + self.inner.header_size = header_size; + self + } + #[inline] + pub fn header_version(mut self, header_version: PipelineCacheHeaderVersion) -> Self { + self.inner.header_version = header_version; + self + } + #[inline] + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.inner.vendor_id = vendor_id; + self + } + #[inline] + pub fn device_id(mut self, device_id: u32) -> Self { + self.inner.device_id = device_id; + self + } + #[inline] + pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCacheHeaderVersionOne { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PushConstantRange { + pub stage_flags: ShaderStageFlags, + pub offset: u32, + pub size: u32, +} +impl PushConstantRange { + pub fn builder<'a>() -> PushConstantRangeBuilder<'a> { + PushConstantRangeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PushConstantRangeBuilder<'a> { + inner: PushConstantRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> { + type Target = PushConstantRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PushConstantRangeBuilder<'a> { + #[inline] + pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self { + self.inner.stage_flags = stage_flags; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PushConstantRange { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineLayoutCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineLayoutCreateFlags, + pub set_layout_count: u32, + pub p_set_layouts: *const DescriptorSetLayout, + pub push_constant_range_count: u32, + pub p_push_constant_ranges: *const PushConstantRange, +} +impl ::std::default::Default for PipelineLayoutCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineLayoutCreateFlags::default(), + set_layout_count: u32::default(), + p_set_layouts: ::std::ptr::null(), + push_constant_range_count: u32::default(), + p_push_constant_ranges: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineLayoutCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_LAYOUT_CREATE_INFO; +} +impl PipelineLayoutCreateInfo { + pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> { + PipelineLayoutCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineLayoutCreateInfoBuilder<'a> { + inner: PipelineLayoutCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> { + type Target = PipelineLayoutCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineLayoutCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineLayoutCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self { + self.inner.set_layout_count = set_layouts.len() as _; + self.inner.p_set_layouts = set_layouts.as_ptr(); + self + } + #[inline] + pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self { + self.inner.push_constant_range_count = push_constant_ranges.len() as _; + self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineLayoutCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SamplerCreateFlags, + pub mag_filter: Filter, + pub min_filter: Filter, + pub mipmap_mode: SamplerMipmapMode, + pub address_mode_u: SamplerAddressMode, + pub address_mode_v: SamplerAddressMode, + pub address_mode_w: SamplerAddressMode, + pub mip_lod_bias: f32, + pub anisotropy_enable: Bool32, + pub max_anisotropy: f32, + pub compare_enable: Bool32, + pub compare_op: CompareOp, + pub min_lod: f32, + pub max_lod: f32, + pub border_color: BorderColor, + pub unnormalized_coordinates: Bool32, +} +impl ::std::default::Default for SamplerCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SamplerCreateFlags::default(), + mag_filter: Filter::default(), + min_filter: Filter::default(), + mipmap_mode: SamplerMipmapMode::default(), + address_mode_u: SamplerAddressMode::default(), + address_mode_v: SamplerAddressMode::default(), + address_mode_w: SamplerAddressMode::default(), + mip_lod_bias: f32::default(), + anisotropy_enable: Bool32::default(), + max_anisotropy: f32::default(), + compare_enable: Bool32::default(), + compare_op: CompareOp::default(), + min_lod: f32::default(), + max_lod: f32::default(), + border_color: BorderColor::default(), + unnormalized_coordinates: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SamplerCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CREATE_INFO; +} +impl SamplerCreateInfo { + pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> { + SamplerCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerCreateInfoBuilder<'a> { + inner: SamplerCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSamplerCreateInfo {} +impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> { + type Target = SamplerCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SamplerCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn mag_filter(mut self, mag_filter: Filter) -> Self { + self.inner.mag_filter = mag_filter; + self + } + #[inline] + pub fn min_filter(mut self, min_filter: Filter) -> Self { + self.inner.min_filter = min_filter; + self + } + #[inline] + pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> Self { + self.inner.mipmap_mode = mipmap_mode; + self + } + #[inline] + pub fn address_mode_u(mut self, address_mode_u: SamplerAddressMode) -> Self { + self.inner.address_mode_u = address_mode_u; + self + } + #[inline] + pub fn address_mode_v(mut self, address_mode_v: SamplerAddressMode) -> Self { + self.inner.address_mode_v = address_mode_v; + self + } + #[inline] + pub fn address_mode_w(mut self, address_mode_w: SamplerAddressMode) -> Self { + self.inner.address_mode_w = address_mode_w; + self + } + #[inline] + pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> Self { + self.inner.mip_lod_bias = mip_lod_bias; + self + } + #[inline] + pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self { + self.inner.anisotropy_enable = anisotropy_enable.into(); + self + } + #[inline] + pub fn max_anisotropy(mut self, max_anisotropy: f32) -> Self { + self.inner.max_anisotropy = max_anisotropy; + self + } + #[inline] + pub fn compare_enable(mut self, compare_enable: bool) -> Self { + self.inner.compare_enable = compare_enable.into(); + self + } + #[inline] + pub fn compare_op(mut self, compare_op: CompareOp) -> Self { + self.inner.compare_op = compare_op; + self + } + #[inline] + pub fn min_lod(mut self, min_lod: f32) -> Self { + self.inner.min_lod = min_lod; + self + } + #[inline] + pub fn max_lod(mut self, max_lod: f32) -> Self { + self.inner.max_lod = max_lod; + self + } + #[inline] + pub fn border_color(mut self, border_color: BorderColor) -> Self { + self.inner.border_color = border_color; + self + } + #[inline] + pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self { + self.inner.unnormalized_coordinates = unnormalized_coordinates.into(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: CommandPoolCreateFlags, + pub queue_family_index: u32, +} +impl ::std::default::Default for CommandPoolCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: CommandPoolCreateFlags::default(), + queue_family_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for CommandPoolCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_POOL_CREATE_INFO; +} +impl CommandPoolCreateInfo { + pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> { + CommandPoolCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandPoolCreateInfoBuilder<'a> { + inner: CommandPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> { + type Target = CommandPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandPoolCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: CommandPoolCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandPoolCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub command_pool: CommandPool, + pub level: CommandBufferLevel, + pub command_buffer_count: u32, +} +impl ::std::default::Default for CommandBufferAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + command_pool: CommandPool::default(), + level: CommandBufferLevel::default(), + command_buffer_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_ALLOCATE_INFO; +} +impl CommandBufferAllocateInfo { + pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> { + CommandBufferAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferAllocateInfoBuilder<'a> { + inner: CommandBufferAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> { + type Target = CommandBufferAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferAllocateInfoBuilder<'a> { + #[inline] + pub fn command_pool(mut self, command_pool: CommandPool) -> Self { + self.inner.command_pool = command_pool; + self + } + #[inline] + pub fn level(mut self, level: CommandBufferLevel) -> Self { + self.inner.level = level; + self + } + #[inline] + pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self { + self.inner.command_buffer_count = command_buffer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub render_pass: RenderPass, + pub subpass: u32, + pub framebuffer: Framebuffer, + pub occlusion_query_enable: Bool32, + pub query_flags: QueryControlFlags, + pub pipeline_statistics: QueryPipelineStatisticFlags, +} +impl ::std::default::Default for CommandBufferInheritanceInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + render_pass: RenderPass::default(), + subpass: u32::default(), + framebuffer: Framebuffer::default(), + occlusion_query_enable: Bool32::default(), + query_flags: QueryControlFlags::default(), + pipeline_statistics: QueryPipelineStatisticFlags::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_INFO; +} +impl CommandBufferInheritanceInfo { + pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> { + CommandBufferInheritanceInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceInfoBuilder<'a> { + inner: CommandBufferInheritanceInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsCommandBufferInheritanceInfo {} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> { + type Target = CommandBufferInheritanceInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceInfoBuilder<'a> { + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn subpass(mut self, subpass: u32) -> Self { + self.inner.subpass = subpass; + self + } + #[inline] + pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self { + self.inner.framebuffer = framebuffer; + self + } + #[inline] + pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self { + self.inner.occlusion_query_enable = occlusion_query_enable.into(); + self + } + #[inline] + pub fn query_flags(mut self, query_flags: QueryControlFlags) -> Self { + self.inner.query_flags = query_flags; + self + } + #[inline] + pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self { + self.inner.pipeline_statistics = pipeline_statistics; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: CommandBufferUsageFlags, + pub p_inheritance_info: *const CommandBufferInheritanceInfo, +} +impl ::std::default::Default for CommandBufferBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: CommandBufferUsageFlags::default(), + p_inheritance_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CommandBufferBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_BEGIN_INFO; +} +impl CommandBufferBeginInfo { + pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> { + CommandBufferBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferBeginInfoBuilder<'a> { + inner: CommandBufferBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsCommandBufferBeginInfo {} +impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> { + type Target = CommandBufferBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferBeginInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: CommandBufferUsageFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn inheritance_info(mut self, inheritance_info: &'a CommandBufferInheritanceInfo) -> Self { + self.inner.p_inheritance_info = inheritance_info; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferBeginInfo { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub render_pass: RenderPass, + pub framebuffer: Framebuffer, + pub render_area: Rect2D, + pub clear_value_count: u32, + pub p_clear_values: *const ClearValue, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderPassBeginInfo { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderPassBeginInfo") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("render_pass", &self.render_pass) + .field("framebuffer", &self.framebuffer) + .field("render_area", &self.render_area) + .field("clear_value_count", &self.clear_value_count) + .field("p_clear_values", &"union") + .finish() + } +} +impl ::std::default::Default for RenderPassBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + render_pass: RenderPass::default(), + framebuffer: Framebuffer::default(), + render_area: Rect2D::default(), + clear_value_count: u32::default(), + p_clear_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_BEGIN_INFO; +} +impl RenderPassBeginInfo { + pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> { + RenderPassBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassBeginInfoBuilder<'a> { + inner: RenderPassBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderPassBeginInfo {} +impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> { + type Target = RenderPassBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassBeginInfoBuilder<'a> { + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self { + self.inner.framebuffer = framebuffer; + self + } + #[inline] + pub fn render_area(mut self, render_area: Rect2D) -> Self { + self.inner.render_area = render_area; + self + } + #[inline] + pub fn clear_values(mut self, clear_values: &'a [ClearValue]) -> Self { + self.inner.clear_value_count = clear_values.len() as _; + self.inner.p_clear_values = clear_values.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassBeginInfo { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union ClearColorValue { + pub float32: [f32; 4], + pub int32: [i32; 4], + pub uint32: [u32; 4], +} +impl ::std::default::Default for ClearColorValue { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ClearDepthStencilValue { + pub depth: f32, + pub stencil: u32, +} +impl ClearDepthStencilValue { + pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> { + ClearDepthStencilValueBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ClearDepthStencilValueBuilder<'a> { + inner: ClearDepthStencilValue, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> { + type Target = ClearDepthStencilValue; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ClearDepthStencilValueBuilder<'a> { + #[inline] + pub fn depth(mut self, depth: f32) -> Self { + self.inner.depth = depth; + self + } + #[inline] + pub fn stencil(mut self, stencil: u32) -> Self { + self.inner.stencil = stencil; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ClearDepthStencilValue { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union ClearValue { + pub color: ClearColorValue, + pub depth_stencil: ClearDepthStencilValue, +} +impl ::std::default::Default for ClearValue { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ClearAttachment { + pub aspect_mask: ImageAspectFlags, + pub color_attachment: u32, + pub clear_value: ClearValue, +} +#[cfg(feature = "debug")] +impl fmt::Debug for ClearAttachment { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("ClearAttachment") + .field("aspect_mask", &self.aspect_mask) + .field("color_attachment", &self.color_attachment) + .field("clear_value", &"union") + .finish() + } +} +impl ClearAttachment { + pub fn builder<'a>() -> ClearAttachmentBuilder<'a> { + ClearAttachmentBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ClearAttachmentBuilder<'a> { + inner: ClearAttachment, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> { + type Target = ClearAttachment; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ClearAttachmentBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn color_attachment(mut self, color_attachment: u32) -> Self { + self.inner.color_attachment = color_attachment; + self + } + #[inline] + pub fn clear_value(mut self, clear_value: ClearValue) -> Self { + self.inner.clear_value = clear_value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ClearAttachment { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AttachmentDescription { + pub flags: AttachmentDescriptionFlags, + pub format: Format, + pub samples: SampleCountFlags, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub stencil_load_op: AttachmentLoadOp, + pub stencil_store_op: AttachmentStoreOp, + pub initial_layout: ImageLayout, + pub final_layout: ImageLayout, +} +impl AttachmentDescription { + pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> { + AttachmentDescriptionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentDescriptionBuilder<'a> { + inner: AttachmentDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> { + type Target = AttachmentDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentDescriptionBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn samples(mut self, samples: SampleCountFlags) -> Self { + self.inner.samples = samples; + self + } + #[inline] + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { + self.inner.load_op = load_op; + self + } + #[inline] + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { + self.inner.store_op = store_op; + self + } + #[inline] + pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self { + self.inner.stencil_load_op = stencil_load_op; + self + } + #[inline] + pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self { + self.inner.stencil_store_op = stencil_store_op; + self + } + #[inline] + pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { + self.inner.initial_layout = initial_layout; + self + } + #[inline] + pub fn final_layout(mut self, final_layout: ImageLayout) -> Self { + self.inner.final_layout = final_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentDescription { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AttachmentReference { + pub attachment: u32, + pub layout: ImageLayout, +} +impl AttachmentReference { + pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> { + AttachmentReferenceBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentReferenceBuilder<'a> { + inner: AttachmentReference, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> { + type Target = AttachmentReference; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentReferenceBuilder<'a> { + #[inline] + pub fn attachment(mut self, attachment: u32) -> Self { + self.inner.attachment = attachment; + self + } + #[inline] + pub fn layout(mut self, layout: ImageLayout) -> Self { + self.inner.layout = layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentReference { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassDescription { + pub flags: SubpassDescriptionFlags, + pub pipeline_bind_point: PipelineBindPoint, + pub input_attachment_count: u32, + pub p_input_attachments: *const AttachmentReference, + pub color_attachment_count: u32, + pub p_color_attachments: *const AttachmentReference, + pub p_resolve_attachments: *const AttachmentReference, + pub p_depth_stencil_attachment: *const AttachmentReference, + pub preserve_attachment_count: u32, + pub p_preserve_attachments: *const u32, +} +impl ::std::default::Default for SubpassDescription { + #[inline] + fn default() -> Self { + Self { + flags: SubpassDescriptionFlags::default(), + pipeline_bind_point: PipelineBindPoint::default(), + input_attachment_count: u32::default(), + p_input_attachments: ::std::ptr::null(), + color_attachment_count: u32::default(), + p_color_attachments: ::std::ptr::null(), + p_resolve_attachments: ::std::ptr::null(), + p_depth_stencil_attachment: ::std::ptr::null(), + preserve_attachment_count: u32::default(), + p_preserve_attachments: ::std::ptr::null(), + } + } +} +impl SubpassDescription { + pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> { + SubpassDescriptionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDescriptionBuilder<'a> { + inner: SubpassDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> { + type Target = SubpassDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDescriptionBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference]) -> Self { + self.inner.input_attachment_count = input_attachments.len() as _; + self.inner.p_input_attachments = input_attachments.as_ptr(); + self + } + #[inline] + pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference]) -> Self { + self.inner.color_attachment_count = color_attachments.len() as _; + self.inner.p_color_attachments = color_attachments.as_ptr(); + self + } + #[inline] + pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference]) -> Self { + self.inner.color_attachment_count = resolve_attachments.len() as _; + self.inner.p_resolve_attachments = resolve_attachments.as_ptr(); + self + } + #[inline] + pub fn depth_stencil_attachment( + mut self, + depth_stencil_attachment: &'a AttachmentReference, + ) -> Self { + self.inner.p_depth_stencil_attachment = depth_stencil_attachment; + self + } + #[inline] + pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self { + self.inner.preserve_attachment_count = preserve_attachments.len() as _; + self.inner.p_preserve_attachments = preserve_attachments.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDescription { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SubpassDependency { + pub src_subpass: u32, + pub dst_subpass: u32, + pub src_stage_mask: PipelineStageFlags, + pub dst_stage_mask: PipelineStageFlags, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub dependency_flags: DependencyFlags, +} +impl SubpassDependency { + pub fn builder<'a>() -> SubpassDependencyBuilder<'a> { + SubpassDependencyBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDependencyBuilder<'a> { + inner: SubpassDependency, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> { + type Target = SubpassDependency; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDependencyBuilder<'a> { + #[inline] + pub fn src_subpass(mut self, src_subpass: u32) -> Self { + self.inner.src_subpass = src_subpass; + self + } + #[inline] + pub fn dst_subpass(mut self, dst_subpass: u32) -> Self { + self.inner.dst_subpass = dst_subpass; + self + } + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { + self.inner.dependency_flags = dependency_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDependency { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderPassCreateFlags, + pub attachment_count: u32, + pub p_attachments: *const AttachmentDescription, + pub subpass_count: u32, + pub p_subpasses: *const SubpassDescription, + pub dependency_count: u32, + pub p_dependencies: *const SubpassDependency, +} +impl ::std::default::Default for RenderPassCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderPassCreateFlags::default(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + subpass_count: u32::default(), + p_subpasses: ::std::ptr::null(), + dependency_count: u32::default(), + p_dependencies: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO; +} +impl RenderPassCreateInfo { + pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> { + RenderPassCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreateInfoBuilder<'a> { + inner: RenderPassCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderPassCreateInfo {} +impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> { + type Target = RenderPassCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn attachments(mut self, attachments: &'a [AttachmentDescription]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[inline] + pub fn subpasses(mut self, subpasses: &'a [SubpassDescription]) -> Self { + self.inner.subpass_count = subpasses.len() as _; + self.inner.p_subpasses = subpasses.as_ptr(); + self + } + #[inline] + pub fn dependencies(mut self, dependencies: &'a [SubpassDependency]) -> Self { + self.inner.dependency_count = dependencies.len() as _; + self.inner.p_dependencies = dependencies.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct EventCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: EventCreateFlags, +} +impl ::std::default::Default for EventCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: EventCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for EventCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EVENT_CREATE_INFO; +} +impl EventCreateInfo { + pub fn builder<'a>() -> EventCreateInfoBuilder<'a> { + EventCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct EventCreateInfoBuilder<'a> { + inner: EventCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsEventCreateInfo {} +impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> { + type Target = EventCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> EventCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: EventCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> EventCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FenceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: FenceCreateFlags, +} +impl ::std::default::Default for FenceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: FenceCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for FenceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::FENCE_CREATE_INFO; +} +impl FenceCreateInfo { + pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> { + FenceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FenceCreateInfoBuilder<'a> { + inner: FenceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsFenceCreateInfo {} +impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> { + type Target = FenceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FenceCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: FenceCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FenceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PhysicalDeviceFeatures { + pub robust_buffer_access: Bool32, + pub full_draw_index_uint32: Bool32, + pub image_cube_array: Bool32, + pub independent_blend: Bool32, + pub geometry_shader: Bool32, + pub tessellation_shader: Bool32, + pub sample_rate_shading: Bool32, + pub dual_src_blend: Bool32, + pub logic_op: Bool32, + pub multi_draw_indirect: Bool32, + pub draw_indirect_first_instance: Bool32, + pub depth_clamp: Bool32, + pub depth_bias_clamp: Bool32, + pub fill_mode_non_solid: Bool32, + pub depth_bounds: Bool32, + pub wide_lines: Bool32, + pub large_points: Bool32, + pub alpha_to_one: Bool32, + pub multi_viewport: Bool32, + pub sampler_anisotropy: Bool32, + pub texture_compression_etc2: Bool32, + pub texture_compression_astc_ldr: Bool32, + pub texture_compression_bc: Bool32, + pub occlusion_query_precise: Bool32, + pub pipeline_statistics_query: Bool32, + pub vertex_pipeline_stores_and_atomics: Bool32, + pub fragment_stores_and_atomics: Bool32, + pub shader_tessellation_and_geometry_point_size: Bool32, + pub shader_image_gather_extended: Bool32, + pub shader_storage_image_extended_formats: Bool32, + pub shader_storage_image_multisample: Bool32, + pub shader_storage_image_read_without_format: Bool32, + pub shader_storage_image_write_without_format: Bool32, + pub shader_uniform_buffer_array_dynamic_indexing: Bool32, + pub shader_sampled_image_array_dynamic_indexing: Bool32, + pub shader_storage_buffer_array_dynamic_indexing: Bool32, + pub shader_storage_image_array_dynamic_indexing: Bool32, + pub shader_clip_distance: Bool32, + pub shader_cull_distance: Bool32, + pub shader_float64: Bool32, + pub shader_int64: Bool32, + pub shader_int16: Bool32, + pub shader_resource_residency: Bool32, + pub shader_resource_min_lod: Bool32, + pub sparse_binding: Bool32, + pub sparse_residency_buffer: Bool32, + pub sparse_residency_image2_d: Bool32, + pub sparse_residency_image3_d: Bool32, + pub sparse_residency2_samples: Bool32, + pub sparse_residency4_samples: Bool32, + pub sparse_residency8_samples: Bool32, + pub sparse_residency16_samples: Bool32, + pub sparse_residency_aliased: Bool32, + pub variable_multisample_rate: Bool32, + pub inherited_queries: Bool32, +} +impl PhysicalDeviceFeatures { + pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> { + PhysicalDeviceFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFeaturesBuilder<'a> { + inner: PhysicalDeviceFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> { + type Target = PhysicalDeviceFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFeaturesBuilder<'a> { + #[inline] + pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self { + self.inner.robust_buffer_access = robust_buffer_access.into(); + self + } + #[inline] + pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self { + self.inner.full_draw_index_uint32 = full_draw_index_uint32.into(); + self + } + #[inline] + pub fn image_cube_array(mut self, image_cube_array: bool) -> Self { + self.inner.image_cube_array = image_cube_array.into(); + self + } + #[inline] + pub fn independent_blend(mut self, independent_blend: bool) -> Self { + self.inner.independent_blend = independent_blend.into(); + self + } + #[inline] + pub fn geometry_shader(mut self, geometry_shader: bool) -> Self { + self.inner.geometry_shader = geometry_shader.into(); + self + } + #[inline] + pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self { + self.inner.tessellation_shader = tessellation_shader.into(); + self + } + #[inline] + pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self { + self.inner.sample_rate_shading = sample_rate_shading.into(); + self + } + #[inline] + pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self { + self.inner.dual_src_blend = dual_src_blend.into(); + self + } + #[inline] + pub fn logic_op(mut self, logic_op: bool) -> Self { + self.inner.logic_op = logic_op.into(); + self + } + #[inline] + pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self { + self.inner.multi_draw_indirect = multi_draw_indirect.into(); + self + } + #[inline] + pub fn draw_indirect_first_instance(mut self, draw_indirect_first_instance: bool) -> Self { + self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into(); + self + } + #[inline] + pub fn depth_clamp(mut self, depth_clamp: bool) -> Self { + self.inner.depth_clamp = depth_clamp.into(); + self + } + #[inline] + pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self { + self.inner.depth_bias_clamp = depth_bias_clamp.into(); + self + } + #[inline] + pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self { + self.inner.fill_mode_non_solid = fill_mode_non_solid.into(); + self + } + #[inline] + pub fn depth_bounds(mut self, depth_bounds: bool) -> Self { + self.inner.depth_bounds = depth_bounds.into(); + self + } + #[inline] + pub fn wide_lines(mut self, wide_lines: bool) -> Self { + self.inner.wide_lines = wide_lines.into(); + self + } + #[inline] + pub fn large_points(mut self, large_points: bool) -> Self { + self.inner.large_points = large_points.into(); + self + } + #[inline] + pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self { + self.inner.alpha_to_one = alpha_to_one.into(); + self + } + #[inline] + pub fn multi_viewport(mut self, multi_viewport: bool) -> Self { + self.inner.multi_viewport = multi_viewport.into(); + self + } + #[inline] + pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self { + self.inner.sampler_anisotropy = sampler_anisotropy.into(); + self + } + #[inline] + pub fn texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self { + self.inner.texture_compression_etc2 = texture_compression_etc2.into(); + self + } + #[inline] + pub fn texture_compression_astc_ldr(mut self, texture_compression_astc_ldr: bool) -> Self { + self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into(); + self + } + #[inline] + pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self { + self.inner.texture_compression_bc = texture_compression_bc.into(); + self + } + #[inline] + pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self { + self.inner.occlusion_query_precise = occlusion_query_precise.into(); + self + } + #[inline] + pub fn pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self { + self.inner.pipeline_statistics_query = pipeline_statistics_query.into(); + self + } + #[inline] + pub fn vertex_pipeline_stores_and_atomics( + mut self, + vertex_pipeline_stores_and_atomics: bool, + ) -> Self { + self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into(); + self + } + #[inline] + pub fn fragment_stores_and_atomics(mut self, fragment_stores_and_atomics: bool) -> Self { + self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into(); + self + } + #[inline] + pub fn shader_tessellation_and_geometry_point_size( + mut self, + shader_tessellation_and_geometry_point_size: bool, + ) -> Self { + self.inner.shader_tessellation_and_geometry_point_size = + shader_tessellation_and_geometry_point_size.into(); + self + } + #[inline] + pub fn shader_image_gather_extended(mut self, shader_image_gather_extended: bool) -> Self { + self.inner.shader_image_gather_extended = shader_image_gather_extended.into(); + self + } + #[inline] + pub fn shader_storage_image_extended_formats( + mut self, + shader_storage_image_extended_formats: bool, + ) -> Self { + self.inner.shader_storage_image_extended_formats = + shader_storage_image_extended_formats.into(); + self + } + #[inline] + pub fn shader_storage_image_multisample( + mut self, + shader_storage_image_multisample: bool, + ) -> Self { + self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into(); + self + } + #[inline] + pub fn shader_storage_image_read_without_format( + mut self, + shader_storage_image_read_without_format: bool, + ) -> Self { + self.inner.shader_storage_image_read_without_format = + shader_storage_image_read_without_format.into(); + self + } + #[inline] + pub fn shader_storage_image_write_without_format( + mut self, + shader_storage_image_write_without_format: bool, + ) -> Self { + self.inner.shader_storage_image_write_without_format = + shader_storage_image_write_without_format.into(); + self + } + #[inline] + pub fn shader_uniform_buffer_array_dynamic_indexing( + mut self, + shader_uniform_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_uniform_buffer_array_dynamic_indexing = + shader_uniform_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_dynamic_indexing( + mut self, + shader_sampled_image_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_sampled_image_array_dynamic_indexing = + shader_sampled_image_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_dynamic_indexing( + mut self, + shader_storage_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_storage_buffer_array_dynamic_indexing = + shader_storage_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_storage_image_array_dynamic_indexing( + mut self, + shader_storage_image_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_storage_image_array_dynamic_indexing = + shader_storage_image_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self { + self.inner.shader_clip_distance = shader_clip_distance.into(); + self + } + #[inline] + pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self { + self.inner.shader_cull_distance = shader_cull_distance.into(); + self + } + #[inline] + pub fn shader_float64(mut self, shader_float64: bool) -> Self { + self.inner.shader_float64 = shader_float64.into(); + self + } + #[inline] + pub fn shader_int64(mut self, shader_int64: bool) -> Self { + self.inner.shader_int64 = shader_int64.into(); + self + } + #[inline] + pub fn shader_int16(mut self, shader_int16: bool) -> Self { + self.inner.shader_int16 = shader_int16.into(); + self + } + #[inline] + pub fn shader_resource_residency(mut self, shader_resource_residency: bool) -> Self { + self.inner.shader_resource_residency = shader_resource_residency.into(); + self + } + #[inline] + pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self { + self.inner.shader_resource_min_lod = shader_resource_min_lod.into(); + self + } + #[inline] + pub fn sparse_binding(mut self, sparse_binding: bool) -> Self { + self.inner.sparse_binding = sparse_binding.into(); + self + } + #[inline] + pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self { + self.inner.sparse_residency_buffer = sparse_residency_buffer.into(); + self + } + #[inline] + pub fn sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self { + self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into(); + self + } + #[inline] + pub fn sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self { + self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into(); + self + } + #[inline] + pub fn sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self { + self.inner.sparse_residency2_samples = sparse_residency2_samples.into(); + self + } + #[inline] + pub fn sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self { + self.inner.sparse_residency4_samples = sparse_residency4_samples.into(); + self + } + #[inline] + pub fn sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self { + self.inner.sparse_residency8_samples = sparse_residency8_samples.into(); + self + } + #[inline] + pub fn sparse_residency16_samples(mut self, sparse_residency16_samples: bool) -> Self { + self.inner.sparse_residency16_samples = sparse_residency16_samples.into(); + self + } + #[inline] + pub fn sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self { + self.inner.sparse_residency_aliased = sparse_residency_aliased.into(); + self + } + #[inline] + pub fn variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self { + self.inner.variable_multisample_rate = variable_multisample_rate.into(); + self + } + #[inline] + pub fn inherited_queries(mut self, inherited_queries: bool) -> Self { + self.inner.inherited_queries = inherited_queries.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PhysicalDeviceSparseProperties { + pub residency_standard2_d_block_shape: Bool32, + pub residency_standard2_d_multisample_block_shape: Bool32, + pub residency_standard3_d_block_shape: Bool32, + pub residency_aligned_mip_size: Bool32, + pub residency_non_resident_strict: Bool32, +} +impl PhysicalDeviceSparseProperties { + pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> { + PhysicalDeviceSparsePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSparsePropertiesBuilder<'a> { + inner: PhysicalDeviceSparseProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> { + type Target = PhysicalDeviceSparseProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> { + #[inline] + pub fn residency_standard2_d_block_shape( + mut self, + residency_standard2_d_block_shape: bool, + ) -> Self { + self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into(); + self + } + #[inline] + pub fn residency_standard2_d_multisample_block_shape( + mut self, + residency_standard2_d_multisample_block_shape: bool, + ) -> Self { + self.inner.residency_standard2_d_multisample_block_shape = + residency_standard2_d_multisample_block_shape.into(); + self + } + #[inline] + pub fn residency_standard3_d_block_shape( + mut self, + residency_standard3_d_block_shape: bool, + ) -> Self { + self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into(); + self + } + #[inline] + pub fn residency_aligned_mip_size(mut self, residency_aligned_mip_size: bool) -> Self { + self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into(); + self + } + #[inline] + pub fn residency_non_resident_strict(mut self, residency_non_resident_strict: bool) -> Self { + self.inner.residency_non_resident_strict = residency_non_resident_strict.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSparseProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLimits { + pub max_image_dimension1_d: u32, + pub max_image_dimension2_d: u32, + pub max_image_dimension3_d: u32, + pub max_image_dimension_cube: u32, + pub max_image_array_layers: u32, + pub max_texel_buffer_elements: u32, + pub max_uniform_buffer_range: u32, + pub max_storage_buffer_range: u32, + pub max_push_constants_size: u32, + pub max_memory_allocation_count: u32, + pub max_sampler_allocation_count: u32, + pub buffer_image_granularity: DeviceSize, + pub sparse_address_space_size: DeviceSize, + pub max_bound_descriptor_sets: u32, + pub max_per_stage_descriptor_samplers: u32, + pub max_per_stage_descriptor_uniform_buffers: u32, + pub max_per_stage_descriptor_storage_buffers: u32, + pub max_per_stage_descriptor_sampled_images: u32, + pub max_per_stage_descriptor_storage_images: u32, + pub max_per_stage_descriptor_input_attachments: u32, + pub max_per_stage_resources: u32, + pub max_descriptor_set_samplers: u32, + pub max_descriptor_set_uniform_buffers: u32, + pub max_descriptor_set_uniform_buffers_dynamic: u32, + pub max_descriptor_set_storage_buffers: u32, + pub max_descriptor_set_storage_buffers_dynamic: u32, + pub max_descriptor_set_sampled_images: u32, + pub max_descriptor_set_storage_images: u32, + pub max_descriptor_set_input_attachments: u32, + pub max_vertex_input_attributes: u32, + pub max_vertex_input_bindings: u32, + pub max_vertex_input_attribute_offset: u32, + pub max_vertex_input_binding_stride: u32, + pub max_vertex_output_components: u32, + pub max_tessellation_generation_level: u32, + pub max_tessellation_patch_size: u32, + pub max_tessellation_control_per_vertex_input_components: u32, + pub max_tessellation_control_per_vertex_output_components: u32, + pub max_tessellation_control_per_patch_output_components: u32, + pub max_tessellation_control_total_output_components: u32, + pub max_tessellation_evaluation_input_components: u32, + pub max_tessellation_evaluation_output_components: u32, + pub max_geometry_shader_invocations: u32, + pub max_geometry_input_components: u32, + pub max_geometry_output_components: u32, + pub max_geometry_output_vertices: u32, + pub max_geometry_total_output_components: u32, + pub max_fragment_input_components: u32, + pub max_fragment_output_attachments: u32, + pub max_fragment_dual_src_attachments: u32, + pub max_fragment_combined_output_resources: u32, + pub max_compute_shared_memory_size: u32, + pub max_compute_work_group_count: [u32; 3], + pub max_compute_work_group_invocations: u32, + pub max_compute_work_group_size: [u32; 3], + pub sub_pixel_precision_bits: u32, + pub sub_texel_precision_bits: u32, + pub mipmap_precision_bits: u32, + pub max_draw_indexed_index_value: u32, + pub max_draw_indirect_count: u32, + pub max_sampler_lod_bias: f32, + pub max_sampler_anisotropy: f32, + pub max_viewports: u32, + pub max_viewport_dimensions: [u32; 2], + pub viewport_bounds_range: [f32; 2], + pub viewport_sub_pixel_bits: u32, + pub min_memory_map_alignment: usize, + pub min_texel_buffer_offset_alignment: DeviceSize, + pub min_uniform_buffer_offset_alignment: DeviceSize, + pub min_storage_buffer_offset_alignment: DeviceSize, + pub min_texel_offset: i32, + pub max_texel_offset: u32, + pub min_texel_gather_offset: i32, + pub max_texel_gather_offset: u32, + pub min_interpolation_offset: f32, + pub max_interpolation_offset: f32, + pub sub_pixel_interpolation_offset_bits: u32, + pub max_framebuffer_width: u32, + pub max_framebuffer_height: u32, + pub max_framebuffer_layers: u32, + pub framebuffer_color_sample_counts: SampleCountFlags, + pub framebuffer_depth_sample_counts: SampleCountFlags, + pub framebuffer_stencil_sample_counts: SampleCountFlags, + pub framebuffer_no_attachments_sample_counts: SampleCountFlags, + pub max_color_attachments: u32, + pub sampled_image_color_sample_counts: SampleCountFlags, + pub sampled_image_integer_sample_counts: SampleCountFlags, + pub sampled_image_depth_sample_counts: SampleCountFlags, + pub sampled_image_stencil_sample_counts: SampleCountFlags, + pub storage_image_sample_counts: SampleCountFlags, + pub max_sample_mask_words: u32, + pub timestamp_compute_and_graphics: Bool32, + pub timestamp_period: f32, + pub max_clip_distances: u32, + pub max_cull_distances: u32, + pub max_combined_clip_and_cull_distances: u32, + pub discrete_queue_priorities: u32, + pub point_size_range: [f32; 2], + pub line_width_range: [f32; 2], + pub point_size_granularity: f32, + pub line_width_granularity: f32, + pub strict_lines: Bool32, + pub standard_sample_locations: Bool32, + pub optimal_buffer_copy_offset_alignment: DeviceSize, + pub optimal_buffer_copy_row_pitch_alignment: DeviceSize, + pub non_coherent_atom_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceLimits { + #[inline] + fn default() -> Self { + Self { + max_image_dimension1_d: u32::default(), + max_image_dimension2_d: u32::default(), + max_image_dimension3_d: u32::default(), + max_image_dimension_cube: u32::default(), + max_image_array_layers: u32::default(), + max_texel_buffer_elements: u32::default(), + max_uniform_buffer_range: u32::default(), + max_storage_buffer_range: u32::default(), + max_push_constants_size: u32::default(), + max_memory_allocation_count: u32::default(), + max_sampler_allocation_count: u32::default(), + buffer_image_granularity: DeviceSize::default(), + sparse_address_space_size: DeviceSize::default(), + max_bound_descriptor_sets: u32::default(), + max_per_stage_descriptor_samplers: u32::default(), + max_per_stage_descriptor_uniform_buffers: u32::default(), + max_per_stage_descriptor_storage_buffers: u32::default(), + max_per_stage_descriptor_sampled_images: u32::default(), + max_per_stage_descriptor_storage_images: u32::default(), + max_per_stage_descriptor_input_attachments: u32::default(), + max_per_stage_resources: u32::default(), + max_descriptor_set_samplers: u32::default(), + max_descriptor_set_uniform_buffers: u32::default(), + max_descriptor_set_uniform_buffers_dynamic: u32::default(), + max_descriptor_set_storage_buffers: u32::default(), + max_descriptor_set_storage_buffers_dynamic: u32::default(), + max_descriptor_set_sampled_images: u32::default(), + max_descriptor_set_storage_images: u32::default(), + max_descriptor_set_input_attachments: u32::default(), + max_vertex_input_attributes: u32::default(), + max_vertex_input_bindings: u32::default(), + max_vertex_input_attribute_offset: u32::default(), + max_vertex_input_binding_stride: u32::default(), + max_vertex_output_components: u32::default(), + max_tessellation_generation_level: u32::default(), + max_tessellation_patch_size: u32::default(), + max_tessellation_control_per_vertex_input_components: u32::default(), + max_tessellation_control_per_vertex_output_components: u32::default(), + max_tessellation_control_per_patch_output_components: u32::default(), + max_tessellation_control_total_output_components: u32::default(), + max_tessellation_evaluation_input_components: u32::default(), + max_tessellation_evaluation_output_components: u32::default(), + max_geometry_shader_invocations: u32::default(), + max_geometry_input_components: u32::default(), + max_geometry_output_components: u32::default(), + max_geometry_output_vertices: u32::default(), + max_geometry_total_output_components: u32::default(), + max_fragment_input_components: u32::default(), + max_fragment_output_attachments: u32::default(), + max_fragment_dual_src_attachments: u32::default(), + max_fragment_combined_output_resources: u32::default(), + max_compute_shared_memory_size: u32::default(), + max_compute_work_group_count: unsafe { ::std::mem::zeroed() }, + max_compute_work_group_invocations: u32::default(), + max_compute_work_group_size: unsafe { ::std::mem::zeroed() }, + sub_pixel_precision_bits: u32::default(), + sub_texel_precision_bits: u32::default(), + mipmap_precision_bits: u32::default(), + max_draw_indexed_index_value: u32::default(), + max_draw_indirect_count: u32::default(), + max_sampler_lod_bias: f32::default(), + max_sampler_anisotropy: f32::default(), + max_viewports: u32::default(), + max_viewport_dimensions: unsafe { ::std::mem::zeroed() }, + viewport_bounds_range: unsafe { ::std::mem::zeroed() }, + viewport_sub_pixel_bits: u32::default(), + min_memory_map_alignment: usize::default(), + min_texel_buffer_offset_alignment: DeviceSize::default(), + min_uniform_buffer_offset_alignment: DeviceSize::default(), + min_storage_buffer_offset_alignment: DeviceSize::default(), + min_texel_offset: i32::default(), + max_texel_offset: u32::default(), + min_texel_gather_offset: i32::default(), + max_texel_gather_offset: u32::default(), + min_interpolation_offset: f32::default(), + max_interpolation_offset: f32::default(), + sub_pixel_interpolation_offset_bits: u32::default(), + max_framebuffer_width: u32::default(), + max_framebuffer_height: u32::default(), + max_framebuffer_layers: u32::default(), + framebuffer_color_sample_counts: SampleCountFlags::default(), + framebuffer_depth_sample_counts: SampleCountFlags::default(), + framebuffer_stencil_sample_counts: SampleCountFlags::default(), + framebuffer_no_attachments_sample_counts: SampleCountFlags::default(), + max_color_attachments: u32::default(), + sampled_image_color_sample_counts: SampleCountFlags::default(), + sampled_image_integer_sample_counts: SampleCountFlags::default(), + sampled_image_depth_sample_counts: SampleCountFlags::default(), + sampled_image_stencil_sample_counts: SampleCountFlags::default(), + storage_image_sample_counts: SampleCountFlags::default(), + max_sample_mask_words: u32::default(), + timestamp_compute_and_graphics: Bool32::default(), + timestamp_period: f32::default(), + max_clip_distances: u32::default(), + max_cull_distances: u32::default(), + max_combined_clip_and_cull_distances: u32::default(), + discrete_queue_priorities: u32::default(), + point_size_range: unsafe { ::std::mem::zeroed() }, + line_width_range: unsafe { ::std::mem::zeroed() }, + point_size_granularity: f32::default(), + line_width_granularity: f32::default(), + strict_lines: Bool32::default(), + standard_sample_locations: Bool32::default(), + optimal_buffer_copy_offset_alignment: DeviceSize::default(), + optimal_buffer_copy_row_pitch_alignment: DeviceSize::default(), + non_coherent_atom_size: DeviceSize::default(), + } + } +} +impl PhysicalDeviceLimits { + pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> { + PhysicalDeviceLimitsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLimitsBuilder<'a> { + inner: PhysicalDeviceLimits, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> { + type Target = PhysicalDeviceLimits; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLimitsBuilder<'a> { + #[inline] + pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self { + self.inner.max_image_dimension1_d = max_image_dimension1_d; + self + } + #[inline] + pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self { + self.inner.max_image_dimension2_d = max_image_dimension2_d; + self + } + #[inline] + pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self { + self.inner.max_image_dimension3_d = max_image_dimension3_d; + self + } + #[inline] + pub fn max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self { + self.inner.max_image_dimension_cube = max_image_dimension_cube; + self + } + #[inline] + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + #[inline] + pub fn max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self { + self.inner.max_texel_buffer_elements = max_texel_buffer_elements; + self + } + #[inline] + pub fn max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self { + self.inner.max_uniform_buffer_range = max_uniform_buffer_range; + self + } + #[inline] + pub fn max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self { + self.inner.max_storage_buffer_range = max_storage_buffer_range; + self + } + #[inline] + pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self { + self.inner.max_push_constants_size = max_push_constants_size; + self + } + #[inline] + pub fn max_memory_allocation_count(mut self, max_memory_allocation_count: u32) -> Self { + self.inner.max_memory_allocation_count = max_memory_allocation_count; + self + } + #[inline] + pub fn max_sampler_allocation_count(mut self, max_sampler_allocation_count: u32) -> Self { + self.inner.max_sampler_allocation_count = max_sampler_allocation_count; + self + } + #[inline] + pub fn buffer_image_granularity(mut self, buffer_image_granularity: DeviceSize) -> Self { + self.inner.buffer_image_granularity = buffer_image_granularity; + self + } + #[inline] + pub fn sparse_address_space_size(mut self, sparse_address_space_size: DeviceSize) -> Self { + self.inner.sparse_address_space_size = sparse_address_space_size; + self + } + #[inline] + pub fn max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self { + self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets; + self + } + #[inline] + pub fn max_per_stage_descriptor_samplers( + mut self, + max_per_stage_descriptor_samplers: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers; + self + } + #[inline] + pub fn max_per_stage_descriptor_uniform_buffers( + mut self, + max_per_stage_descriptor_uniform_buffers: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_uniform_buffers = + max_per_stage_descriptor_uniform_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_storage_buffers( + mut self, + max_per_stage_descriptor_storage_buffers: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_storage_buffers = + max_per_stage_descriptor_storage_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_sampled_images( + mut self, + max_per_stage_descriptor_sampled_images: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_sampled_images = + max_per_stage_descriptor_sampled_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_storage_images( + mut self, + max_per_stage_descriptor_storage_images: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_storage_images = + max_per_stage_descriptor_storage_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_input_attachments( + mut self, + max_per_stage_descriptor_input_attachments: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_input_attachments = + max_per_stage_descriptor_input_attachments; + self + } + #[inline] + pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self { + self.inner.max_per_stage_resources = max_per_stage_resources; + self + } + #[inline] + pub fn max_descriptor_set_samplers(mut self, max_descriptor_set_samplers: u32) -> Self { + self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers; + self + } + #[inline] + pub fn max_descriptor_set_uniform_buffers( + mut self, + max_descriptor_set_uniform_buffers: u32, + ) -> Self { + self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers; + self + } + #[inline] + pub fn max_descriptor_set_uniform_buffers_dynamic( + mut self, + max_descriptor_set_uniform_buffers_dynamic: u32, + ) -> Self { + self.inner.max_descriptor_set_uniform_buffers_dynamic = + max_descriptor_set_uniform_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_storage_buffers( + mut self, + max_descriptor_set_storage_buffers: u32, + ) -> Self { + self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers; + self + } + #[inline] + pub fn max_descriptor_set_storage_buffers_dynamic( + mut self, + max_descriptor_set_storage_buffers_dynamic: u32, + ) -> Self { + self.inner.max_descriptor_set_storage_buffers_dynamic = + max_descriptor_set_storage_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_sampled_images( + mut self, + max_descriptor_set_sampled_images: u32, + ) -> Self { + self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images; + self + } + #[inline] + pub fn max_descriptor_set_storage_images( + mut self, + max_descriptor_set_storage_images: u32, + ) -> Self { + self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images; + self + } + #[inline] + pub fn max_descriptor_set_input_attachments( + mut self, + max_descriptor_set_input_attachments: u32, + ) -> Self { + self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments; + self + } + #[inline] + pub fn max_vertex_input_attributes(mut self, max_vertex_input_attributes: u32) -> Self { + self.inner.max_vertex_input_attributes = max_vertex_input_attributes; + self + } + #[inline] + pub fn max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self { + self.inner.max_vertex_input_bindings = max_vertex_input_bindings; + self + } + #[inline] + pub fn max_vertex_input_attribute_offset( + mut self, + max_vertex_input_attribute_offset: u32, + ) -> Self { + self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset; + self + } + #[inline] + pub fn max_vertex_input_binding_stride(mut self, max_vertex_input_binding_stride: u32) -> Self { + self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride; + self + } + #[inline] + pub fn max_vertex_output_components(mut self, max_vertex_output_components: u32) -> Self { + self.inner.max_vertex_output_components = max_vertex_output_components; + self + } + #[inline] + pub fn max_tessellation_generation_level( + mut self, + max_tessellation_generation_level: u32, + ) -> Self { + self.inner.max_tessellation_generation_level = max_tessellation_generation_level; + self + } + #[inline] + pub fn max_tessellation_patch_size(mut self, max_tessellation_patch_size: u32) -> Self { + self.inner.max_tessellation_patch_size = max_tessellation_patch_size; + self + } + #[inline] + pub fn max_tessellation_control_per_vertex_input_components( + mut self, + max_tessellation_control_per_vertex_input_components: u32, + ) -> Self { + self.inner + .max_tessellation_control_per_vertex_input_components = + max_tessellation_control_per_vertex_input_components; + self + } + #[inline] + pub fn max_tessellation_control_per_vertex_output_components( + mut self, + max_tessellation_control_per_vertex_output_components: u32, + ) -> Self { + self.inner + .max_tessellation_control_per_vertex_output_components = + max_tessellation_control_per_vertex_output_components; + self + } + #[inline] + pub fn max_tessellation_control_per_patch_output_components( + mut self, + max_tessellation_control_per_patch_output_components: u32, + ) -> Self { + self.inner + .max_tessellation_control_per_patch_output_components = + max_tessellation_control_per_patch_output_components; + self + } + #[inline] + pub fn max_tessellation_control_total_output_components( + mut self, + max_tessellation_control_total_output_components: u32, + ) -> Self { + self.inner.max_tessellation_control_total_output_components = + max_tessellation_control_total_output_components; + self + } + #[inline] + pub fn max_tessellation_evaluation_input_components( + mut self, + max_tessellation_evaluation_input_components: u32, + ) -> Self { + self.inner.max_tessellation_evaluation_input_components = + max_tessellation_evaluation_input_components; + self + } + #[inline] + pub fn max_tessellation_evaluation_output_components( + mut self, + max_tessellation_evaluation_output_components: u32, + ) -> Self { + self.inner.max_tessellation_evaluation_output_components = + max_tessellation_evaluation_output_components; + self + } + #[inline] + pub fn max_geometry_shader_invocations(mut self, max_geometry_shader_invocations: u32) -> Self { + self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations; + self + } + #[inline] + pub fn max_geometry_input_components(mut self, max_geometry_input_components: u32) -> Self { + self.inner.max_geometry_input_components = max_geometry_input_components; + self + } + #[inline] + pub fn max_geometry_output_components(mut self, max_geometry_output_components: u32) -> Self { + self.inner.max_geometry_output_components = max_geometry_output_components; + self + } + #[inline] + pub fn max_geometry_output_vertices(mut self, max_geometry_output_vertices: u32) -> Self { + self.inner.max_geometry_output_vertices = max_geometry_output_vertices; + self + } + #[inline] + pub fn max_geometry_total_output_components( + mut self, + max_geometry_total_output_components: u32, + ) -> Self { + self.inner.max_geometry_total_output_components = max_geometry_total_output_components; + self + } + #[inline] + pub fn max_fragment_input_components(mut self, max_fragment_input_components: u32) -> Self { + self.inner.max_fragment_input_components = max_fragment_input_components; + self + } + #[inline] + pub fn max_fragment_output_attachments(mut self, max_fragment_output_attachments: u32) -> Self { + self.inner.max_fragment_output_attachments = max_fragment_output_attachments; + self + } + #[inline] + pub fn max_fragment_dual_src_attachments( + mut self, + max_fragment_dual_src_attachments: u32, + ) -> Self { + self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments; + self + } + #[inline] + pub fn max_fragment_combined_output_resources( + mut self, + max_fragment_combined_output_resources: u32, + ) -> Self { + self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources; + self + } + #[inline] + pub fn max_compute_shared_memory_size(mut self, max_compute_shared_memory_size: u32) -> Self { + self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size; + self + } + #[inline] + pub fn max_compute_work_group_count(mut self, max_compute_work_group_count: [u32; 3]) -> Self { + self.inner.max_compute_work_group_count = max_compute_work_group_count; + self + } + #[inline] + pub fn max_compute_work_group_invocations( + mut self, + max_compute_work_group_invocations: u32, + ) -> Self { + self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations; + self + } + #[inline] + pub fn max_compute_work_group_size(mut self, max_compute_work_group_size: [u32; 3]) -> Self { + self.inner.max_compute_work_group_size = max_compute_work_group_size; + self + } + #[inline] + pub fn sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self { + self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits; + self + } + #[inline] + pub fn sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self { + self.inner.sub_texel_precision_bits = sub_texel_precision_bits; + self + } + #[inline] + pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self { + self.inner.mipmap_precision_bits = mipmap_precision_bits; + self + } + #[inline] + pub fn max_draw_indexed_index_value(mut self, max_draw_indexed_index_value: u32) -> Self { + self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value; + self + } + #[inline] + pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self { + self.inner.max_draw_indirect_count = max_draw_indirect_count; + self + } + #[inline] + pub fn max_sampler_lod_bias(mut self, max_sampler_lod_bias: f32) -> Self { + self.inner.max_sampler_lod_bias = max_sampler_lod_bias; + self + } + #[inline] + pub fn max_sampler_anisotropy(mut self, max_sampler_anisotropy: f32) -> Self { + self.inner.max_sampler_anisotropy = max_sampler_anisotropy; + self + } + #[inline] + pub fn max_viewports(mut self, max_viewports: u32) -> Self { + self.inner.max_viewports = max_viewports; + self + } + #[inline] + pub fn max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self { + self.inner.max_viewport_dimensions = max_viewport_dimensions; + self + } + #[inline] + pub fn viewport_bounds_range(mut self, viewport_bounds_range: [f32; 2]) -> Self { + self.inner.viewport_bounds_range = viewport_bounds_range; + self + } + #[inline] + pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self { + self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits; + self + } + #[inline] + pub fn min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self { + self.inner.min_memory_map_alignment = min_memory_map_alignment; + self + } + #[inline] + pub fn min_texel_buffer_offset_alignment( + mut self, + min_texel_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment; + self + } + #[inline] + pub fn min_uniform_buffer_offset_alignment( + mut self, + min_uniform_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment; + self + } + #[inline] + pub fn min_storage_buffer_offset_alignment( + mut self, + min_storage_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment; + self + } + #[inline] + pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self { + self.inner.min_texel_offset = min_texel_offset; + self + } + #[inline] + pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self { + self.inner.max_texel_offset = max_texel_offset; + self + } + #[inline] + pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self { + self.inner.min_texel_gather_offset = min_texel_gather_offset; + self + } + #[inline] + pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self { + self.inner.max_texel_gather_offset = max_texel_gather_offset; + self + } + #[inline] + pub fn min_interpolation_offset(mut self, min_interpolation_offset: f32) -> Self { + self.inner.min_interpolation_offset = min_interpolation_offset; + self + } + #[inline] + pub fn max_interpolation_offset(mut self, max_interpolation_offset: f32) -> Self { + self.inner.max_interpolation_offset = max_interpolation_offset; + self + } + #[inline] + pub fn sub_pixel_interpolation_offset_bits( + mut self, + sub_pixel_interpolation_offset_bits: u32, + ) -> Self { + self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits; + self + } + #[inline] + pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self { + self.inner.max_framebuffer_width = max_framebuffer_width; + self + } + #[inline] + pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self { + self.inner.max_framebuffer_height = max_framebuffer_height; + self + } + #[inline] + pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self { + self.inner.max_framebuffer_layers = max_framebuffer_layers; + self + } + #[inline] + pub fn framebuffer_color_sample_counts( + mut self, + framebuffer_color_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts; + self + } + #[inline] + pub fn framebuffer_depth_sample_counts( + mut self, + framebuffer_depth_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts; + self + } + #[inline] + pub fn framebuffer_stencil_sample_counts( + mut self, + framebuffer_stencil_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts; + self + } + #[inline] + pub fn framebuffer_no_attachments_sample_counts( + mut self, + framebuffer_no_attachments_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_no_attachments_sample_counts = + framebuffer_no_attachments_sample_counts; + self + } + #[inline] + pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self { + self.inner.max_color_attachments = max_color_attachments; + self + } + #[inline] + pub fn sampled_image_color_sample_counts( + mut self, + sampled_image_color_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts; + self + } + #[inline] + pub fn sampled_image_integer_sample_counts( + mut self, + sampled_image_integer_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts; + self + } + #[inline] + pub fn sampled_image_depth_sample_counts( + mut self, + sampled_image_depth_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts; + self + } + #[inline] + pub fn sampled_image_stencil_sample_counts( + mut self, + sampled_image_stencil_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts; + self + } + #[inline] + pub fn storage_image_sample_counts( + mut self, + storage_image_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.storage_image_sample_counts = storage_image_sample_counts; + self + } + #[inline] + pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self { + self.inner.max_sample_mask_words = max_sample_mask_words; + self + } + #[inline] + pub fn timestamp_compute_and_graphics(mut self, timestamp_compute_and_graphics: bool) -> Self { + self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into(); + self + } + #[inline] + pub fn timestamp_period(mut self, timestamp_period: f32) -> Self { + self.inner.timestamp_period = timestamp_period; + self + } + #[inline] + pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self { + self.inner.max_clip_distances = max_clip_distances; + self + } + #[inline] + pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self { + self.inner.max_cull_distances = max_cull_distances; + self + } + #[inline] + pub fn max_combined_clip_and_cull_distances( + mut self, + max_combined_clip_and_cull_distances: u32, + ) -> Self { + self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances; + self + } + #[inline] + pub fn discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self { + self.inner.discrete_queue_priorities = discrete_queue_priorities; + self + } + #[inline] + pub fn point_size_range(mut self, point_size_range: [f32; 2]) -> Self { + self.inner.point_size_range = point_size_range; + self + } + #[inline] + pub fn line_width_range(mut self, line_width_range: [f32; 2]) -> Self { + self.inner.line_width_range = line_width_range; + self + } + #[inline] + pub fn point_size_granularity(mut self, point_size_granularity: f32) -> Self { + self.inner.point_size_granularity = point_size_granularity; + self + } + #[inline] + pub fn line_width_granularity(mut self, line_width_granularity: f32) -> Self { + self.inner.line_width_granularity = line_width_granularity; + self + } + #[inline] + pub fn strict_lines(mut self, strict_lines: bool) -> Self { + self.inner.strict_lines = strict_lines.into(); + self + } + #[inline] + pub fn standard_sample_locations(mut self, standard_sample_locations: bool) -> Self { + self.inner.standard_sample_locations = standard_sample_locations.into(); + self + } + #[inline] + pub fn optimal_buffer_copy_offset_alignment( + mut self, + optimal_buffer_copy_offset_alignment: DeviceSize, + ) -> Self { + self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment; + self + } + #[inline] + pub fn optimal_buffer_copy_row_pitch_alignment( + mut self, + optimal_buffer_copy_row_pitch_alignment: DeviceSize, + ) -> Self { + self.inner.optimal_buffer_copy_row_pitch_alignment = + optimal_buffer_copy_row_pitch_alignment; + self + } + #[inline] + pub fn non_coherent_atom_size(mut self, non_coherent_atom_size: DeviceSize) -> Self { + self.inner.non_coherent_atom_size = non_coherent_atom_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLimits { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SemaphoreCreateFlags, +} +impl ::std::default::Default for SemaphoreCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SemaphoreCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_CREATE_INFO; +} +impl SemaphoreCreateInfo { + pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> { + SemaphoreCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreCreateInfoBuilder<'a> { + inner: SemaphoreCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSemaphoreCreateInfo {} +impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> { + type Target = SemaphoreCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SemaphoreCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueryPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: QueryPoolCreateFlags, + pub query_type: QueryType, + pub query_count: u32, + pub pipeline_statistics: QueryPipelineStatisticFlags, +} +impl ::std::default::Default for QueryPoolCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: QueryPoolCreateFlags::default(), + query_type: QueryType::default(), + query_count: u32::default(), + pipeline_statistics: QueryPipelineStatisticFlags::default(), + } + } +} +unsafe impl TaggedStructure for QueryPoolCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::QUERY_POOL_CREATE_INFO; +} +impl QueryPoolCreateInfo { + pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> { + QueryPoolCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueryPoolCreateInfoBuilder<'a> { + inner: QueryPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsQueryPoolCreateInfo {} +impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> { + type Target = QueryPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueryPoolCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: QueryPoolCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn query_type(mut self, query_type: QueryType) -> Self { + self.inner.query_type = query_type; + self + } + #[inline] + pub fn query_count(mut self, query_count: u32) -> Self { + self.inner.query_count = query_count; + self + } + #[inline] + pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self { + self.inner.pipeline_statistics = pipeline_statistics; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueryPoolCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FramebufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: FramebufferCreateFlags, + pub render_pass: RenderPass, + pub attachment_count: u32, + pub p_attachments: *const ImageView, + pub width: u32, + pub height: u32, + pub layers: u32, +} +impl ::std::default::Default for FramebufferCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: FramebufferCreateFlags::default(), + render_pass: RenderPass::default(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + width: u32::default(), + height: u32::default(), + layers: u32::default(), + } + } +} +unsafe impl TaggedStructure for FramebufferCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_CREATE_INFO; +} +impl FramebufferCreateInfo { + pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> { + FramebufferCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FramebufferCreateInfoBuilder<'a> { + inner: FramebufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsFramebufferCreateInfo {} +impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> { + type Target = FramebufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FramebufferCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: FramebufferCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn layers(mut self, layers: u32) -> Self { + self.inner.layers = layers; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FramebufferCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrawIndirectCommand { + pub vertex_count: u32, + pub instance_count: u32, + pub first_vertex: u32, + pub first_instance: u32, +} +impl DrawIndirectCommand { + pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> { + DrawIndirectCommandBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrawIndirectCommandBuilder<'a> { + inner: DrawIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> { + type Target = DrawIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrawIndirectCommandBuilder<'a> { + #[inline] + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.inner.vertex_count = vertex_count; + self + } + #[inline] + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.inner.instance_count = instance_count; + self + } + #[inline] + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.inner.first_vertex = first_vertex; + self + } + #[inline] + pub fn first_instance(mut self, first_instance: u32) -> Self { + self.inner.first_instance = first_instance; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrawIndirectCommand { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrawIndexedIndirectCommand { + pub index_count: u32, + pub instance_count: u32, + pub first_index: u32, + pub vertex_offset: i32, + pub first_instance: u32, +} +impl DrawIndexedIndirectCommand { + pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> { + DrawIndexedIndirectCommandBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrawIndexedIndirectCommandBuilder<'a> { + inner: DrawIndexedIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> { + type Target = DrawIndexedIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrawIndexedIndirectCommandBuilder<'a> { + #[inline] + pub fn index_count(mut self, index_count: u32) -> Self { + self.inner.index_count = index_count; + self + } + #[inline] + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.inner.instance_count = instance_count; + self + } + #[inline] + pub fn first_index(mut self, first_index: u32) -> Self { + self.inner.first_index = first_index; + self + } + #[inline] + pub fn vertex_offset(mut self, vertex_offset: i32) -> Self { + self.inner.vertex_offset = vertex_offset; + self + } + #[inline] + pub fn first_instance(mut self, first_instance: u32) -> Self { + self.inner.first_instance = first_instance; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrawIndexedIndirectCommand { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DispatchIndirectCommand { + pub x: u32, + pub y: u32, + pub z: u32, +} +impl DispatchIndirectCommand { + pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> { + DispatchIndirectCommandBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DispatchIndirectCommandBuilder<'a> { + inner: DispatchIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> { + type Target = DispatchIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DispatchIndirectCommandBuilder<'a> { + #[inline] + pub fn x(mut self, x: u32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: u32) -> Self { + self.inner.y = y; + self + } + #[inline] + pub fn z(mut self, z: u32) -> Self { + self.inner.z = z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DispatchIndirectCommand { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MultiDrawInfoEXT { + pub first_vertex: u32, + pub vertex_count: u32, +} +impl MultiDrawInfoEXT { + pub fn builder<'a>() -> MultiDrawInfoEXTBuilder<'a> { + MultiDrawInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultiDrawInfoEXTBuilder<'a> { + inner: MultiDrawInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MultiDrawInfoEXTBuilder<'a> { + type Target = MultiDrawInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultiDrawInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultiDrawInfoEXTBuilder<'a> { + #[inline] + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.inner.first_vertex = first_vertex; + self + } + #[inline] + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.inner.vertex_count = vertex_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultiDrawInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MultiDrawIndexedInfoEXT { + pub first_index: u32, + pub index_count: u32, + pub vertex_offset: i32, +} +impl MultiDrawIndexedInfoEXT { + pub fn builder<'a>() -> MultiDrawIndexedInfoEXTBuilder<'a> { + MultiDrawIndexedInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultiDrawIndexedInfoEXTBuilder<'a> { + inner: MultiDrawIndexedInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MultiDrawIndexedInfoEXTBuilder<'a> { + type Target = MultiDrawIndexedInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultiDrawIndexedInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultiDrawIndexedInfoEXTBuilder<'a> { + #[inline] + pub fn first_index(mut self, first_index: u32) -> Self { + self.inner.first_index = first_index; + self + } + #[inline] + pub fn index_count(mut self, index_count: u32) -> Self { + self.inner.index_count = index_count; + self + } + #[inline] + pub fn vertex_offset(mut self, vertex_offset: i32) -> Self { + self.inner.vertex_offset = vertex_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultiDrawIndexedInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: u32, + pub p_wait_semaphores: *const Semaphore, + pub p_wait_dst_stage_mask: *const PipelineStageFlags, + pub command_buffer_count: u32, + pub p_command_buffers: *const CommandBuffer, + pub signal_semaphore_count: u32, + pub p_signal_semaphores: *const Semaphore, +} +impl ::std::default::Default for SubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_count: u32::default(), + p_wait_semaphores: ::std::ptr::null(), + p_wait_dst_stage_mask: ::std::ptr::null(), + command_buffer_count: u32::default(), + p_command_buffers: ::std::ptr::null(), + signal_semaphore_count: u32::default(), + p_signal_semaphores: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SUBMIT_INFO; +} +impl SubmitInfo { + pub fn builder<'a>() -> SubmitInfoBuilder<'a> { + SubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubmitInfoBuilder<'a> { + inner: SubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubmitInfo {} +impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> { + type Target = SubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubmitInfoBuilder<'a> { + #[inline] + pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { + self.inner.wait_semaphore_count = wait_semaphores.len() as _; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + #[inline] + pub fn wait_dst_stage_mask(mut self, wait_dst_stage_mask: &'a [PipelineStageFlags]) -> Self { + self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _; + self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr(); + self + } + #[inline] + pub fn command_buffers(mut self, command_buffers: &'a [CommandBuffer]) -> Self { + self.inner.command_buffer_count = command_buffers.len() as _; + self.inner.p_command_buffers = command_buffers.as_ptr(); + self + } + #[inline] + pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self { + self.inner.signal_semaphore_count = signal_semaphores.len() as _; + self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPropertiesKHR { + pub display: DisplayKHR, + pub display_name: *const c_char, + pub physical_dimensions: Extent2D, + pub physical_resolution: Extent2D, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub plane_reorder_possible: Bool32, + pub persistent_content: Bool32, +} +impl ::std::default::Default for DisplayPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + display: DisplayKHR::default(), + display_name: ::std::ptr::null(), + physical_dimensions: Extent2D::default(), + physical_resolution: Extent2D::default(), + supported_transforms: SurfaceTransformFlagsKHR::default(), + plane_reorder_possible: Bool32::default(), + persistent_content: Bool32::default(), + } + } +} +impl DisplayPropertiesKHR { + pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> { + DisplayPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPropertiesKHRBuilder<'a> { + inner: DisplayPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> { + type Target = DisplayPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPropertiesKHRBuilder<'a> { + #[inline] + pub fn display(mut self, display: DisplayKHR) -> Self { + self.inner.display = display; + self + } + #[inline] + pub fn display_name(mut self, display_name: &'a ::std::ffi::CStr) -> Self { + self.inner.display_name = display_name.as_ptr(); + self + } + #[inline] + pub fn physical_dimensions(mut self, physical_dimensions: Extent2D) -> Self { + self.inner.physical_dimensions = physical_dimensions; + self + } + #[inline] + pub fn physical_resolution(mut self, physical_resolution: Extent2D) -> Self { + self.inner.physical_resolution = physical_resolution; + self + } + #[inline] + pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { + self.inner.supported_transforms = supported_transforms; + self + } + #[inline] + pub fn plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self { + self.inner.plane_reorder_possible = plane_reorder_possible.into(); + self + } + #[inline] + pub fn persistent_content(mut self, persistent_content: bool) -> Self { + self.inner.persistent_content = persistent_content.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DisplayPlanePropertiesKHR { + pub current_display: DisplayKHR, + pub current_stack_index: u32, +} +impl DisplayPlanePropertiesKHR { + pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> { + DisplayPlanePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlanePropertiesKHRBuilder<'a> { + inner: DisplayPlanePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> { + type Target = DisplayPlanePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlanePropertiesKHRBuilder<'a> { + #[inline] + pub fn current_display(mut self, current_display: DisplayKHR) -> Self { + self.inner.current_display = current_display; + self + } + #[inline] + pub fn current_stack_index(mut self, current_stack_index: u32) -> Self { + self.inner.current_stack_index = current_stack_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlanePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DisplayModeParametersKHR { + pub visible_region: Extent2D, + pub refresh_rate: u32, +} +impl DisplayModeParametersKHR { + pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> { + DisplayModeParametersKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayModeParametersKHRBuilder<'a> { + inner: DisplayModeParametersKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> { + type Target = DisplayModeParametersKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayModeParametersKHRBuilder<'a> { + #[inline] + pub fn visible_region(mut self, visible_region: Extent2D) -> Self { + self.inner.visible_region = visible_region; + self + } + #[inline] + pub fn refresh_rate(mut self, refresh_rate: u32) -> Self { + self.inner.refresh_rate = refresh_rate; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayModeParametersKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DisplayModePropertiesKHR { + pub display_mode: DisplayModeKHR, + pub parameters: DisplayModeParametersKHR, +} +impl DisplayModePropertiesKHR { + pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> { + DisplayModePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayModePropertiesKHRBuilder<'a> { + inner: DisplayModePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> { + type Target = DisplayModePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayModePropertiesKHRBuilder<'a> { + #[inline] + pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self { + self.inner.display_mode = display_mode; + self + } + #[inline] + pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self { + self.inner.parameters = parameters; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayModePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayModeCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DisplayModeCreateFlagsKHR, + pub parameters: DisplayModeParametersKHR, +} +impl ::std::default::Default for DisplayModeCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DisplayModeCreateFlagsKHR::default(), + parameters: DisplayModeParametersKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayModeCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_CREATE_INFO_KHR; +} +impl DisplayModeCreateInfoKHR { + pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> { + DisplayModeCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayModeCreateInfoKHRBuilder<'a> { + inner: DisplayModeCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> { + type Target = DisplayModeCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DisplayModeCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self { + self.inner.parameters = parameters; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayModeCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DisplayPlaneCapabilitiesKHR { + pub supported_alpha: DisplayPlaneAlphaFlagsKHR, + pub min_src_position: Offset2D, + pub max_src_position: Offset2D, + pub min_src_extent: Extent2D, + pub max_src_extent: Extent2D, + pub min_dst_position: Offset2D, + pub max_dst_position: Offset2D, + pub min_dst_extent: Extent2D, + pub max_dst_extent: Extent2D, +} +impl DisplayPlaneCapabilitiesKHR { + pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + DisplayPlaneCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> { + inner: DisplayPlaneCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> { + type Target = DisplayPlaneCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn supported_alpha(mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR) -> Self { + self.inner.supported_alpha = supported_alpha; + self + } + #[inline] + pub fn min_src_position(mut self, min_src_position: Offset2D) -> Self { + self.inner.min_src_position = min_src_position; + self + } + #[inline] + pub fn max_src_position(mut self, max_src_position: Offset2D) -> Self { + self.inner.max_src_position = max_src_position; + self + } + #[inline] + pub fn min_src_extent(mut self, min_src_extent: Extent2D) -> Self { + self.inner.min_src_extent = min_src_extent; + self + } + #[inline] + pub fn max_src_extent(mut self, max_src_extent: Extent2D) -> Self { + self.inner.max_src_extent = max_src_extent; + self + } + #[inline] + pub fn min_dst_position(mut self, min_dst_position: Offset2D) -> Self { + self.inner.min_dst_position = min_dst_position; + self + } + #[inline] + pub fn max_dst_position(mut self, max_dst_position: Offset2D) -> Self { + self.inner.max_dst_position = max_dst_position; + self + } + #[inline] + pub fn min_dst_extent(mut self, min_dst_extent: Extent2D) -> Self { + self.inner.min_dst_extent = min_dst_extent; + self + } + #[inline] + pub fn max_dst_extent(mut self, max_dst_extent: Extent2D) -> Self { + self.inner.max_dst_extent = max_dst_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlaneCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplaySurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DisplaySurfaceCreateFlagsKHR, + pub display_mode: DisplayModeKHR, + pub plane_index: u32, + pub plane_stack_index: u32, + pub transform: SurfaceTransformFlagsKHR, + pub global_alpha: f32, + pub alpha_mode: DisplayPlaneAlphaFlagsKHR, + pub image_extent: Extent2D, +} +impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DisplaySurfaceCreateFlagsKHR::default(), + display_mode: DisplayModeKHR::default(), + plane_index: u32::default(), + plane_stack_index: u32::default(), + transform: SurfaceTransformFlagsKHR::default(), + global_alpha: f32::default(), + alpha_mode: DisplayPlaneAlphaFlagsKHR::default(), + image_extent: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for DisplaySurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR; +} +impl DisplaySurfaceCreateInfoKHR { + pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + DisplaySurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> { + inner: DisplaySurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> { + type Target = DisplaySurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DisplaySurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self { + self.inner.display_mode = display_mode; + self + } + #[inline] + pub fn plane_index(mut self, plane_index: u32) -> Self { + self.inner.plane_index = plane_index; + self + } + #[inline] + pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self { + self.inner.plane_stack_index = plane_stack_index; + self + } + #[inline] + pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.transform = transform; + self + } + #[inline] + pub fn global_alpha(mut self, global_alpha: f32) -> Self { + self.inner.global_alpha = global_alpha; + self + } + #[inline] + pub fn alpha_mode(mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR) -> Self { + self.inner.alpha_mode = alpha_mode; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent2D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplaySurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_rect: Rect2D, + pub dst_rect: Rect2D, + pub persistent: Bool32, +} +impl ::std::default::Default for DisplayPresentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_rect: Rect2D::default(), + dst_rect: Rect2D::default(), + persistent: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPresentInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PRESENT_INFO_KHR; +} +impl DisplayPresentInfoKHR { + pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> { + DisplayPresentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPresentInfoKHRBuilder<'a> { + inner: DisplayPresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {} +impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> { + type Target = DisplayPresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPresentInfoKHRBuilder<'a> { + #[inline] + pub fn src_rect(mut self, src_rect: Rect2D) -> Self { + self.inner.src_rect = src_rect; + self + } + #[inline] + pub fn dst_rect(mut self, dst_rect: Rect2D) -> Self { + self.inner.dst_rect = dst_rect; + self + } + #[inline] + pub fn persistent(mut self, persistent: bool) -> Self { + self.inner.persistent = persistent.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPresentInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SurfaceCapabilitiesKHR { + pub min_image_count: u32, + pub max_image_count: u32, + pub current_extent: Extent2D, + pub min_image_extent: Extent2D, + pub max_image_extent: Extent2D, + pub max_image_array_layers: u32, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub current_transform: SurfaceTransformFlagsKHR, + pub supported_composite_alpha: CompositeAlphaFlagsKHR, + pub supported_usage_flags: ImageUsageFlags, +} +impl SurfaceCapabilitiesKHR { + pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> { + SurfaceCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilitiesKHRBuilder<'a> { + inner: SurfaceCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> { + type Target = SurfaceCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.inner.min_image_count = min_image_count; + self + } + #[inline] + pub fn max_image_count(mut self, max_image_count: u32) -> Self { + self.inner.max_image_count = max_image_count; + self + } + #[inline] + pub fn current_extent(mut self, current_extent: Extent2D) -> Self { + self.inner.current_extent = current_extent; + self + } + #[inline] + pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self { + self.inner.min_image_extent = min_image_extent; + self + } + #[inline] + pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self { + self.inner.max_image_extent = max_image_extent; + self + } + #[inline] + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + #[inline] + pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { + self.inner.supported_transforms = supported_transforms; + self + } + #[inline] + pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.current_transform = current_transform; + self + } + #[inline] + pub fn supported_composite_alpha( + mut self, + supported_composite_alpha: CompositeAlphaFlagsKHR, + ) -> Self { + self.inner.supported_composite_alpha = supported_composite_alpha; + self + } + #[inline] + pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self { + self.inner.supported_usage_flags = supported_usage_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: AndroidSurfaceCreateFlagsKHR, + pub window: *mut ANativeWindow, +} +impl ::std::default::Default for AndroidSurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: AndroidSurfaceCreateFlagsKHR::default(), + window: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for AndroidSurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_SURFACE_CREATE_INFO_KHR; +} +impl AndroidSurfaceCreateInfoKHR { + pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> { + AndroidSurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> { + inner: AndroidSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> { + type Target = AndroidSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: AndroidSurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn window(mut self, window: *mut ANativeWindow) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidSurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ViSurfaceCreateInfoNN { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ViSurfaceCreateFlagsNN, + pub window: *mut c_void, +} +impl ::std::default::Default for ViSurfaceCreateInfoNN { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ViSurfaceCreateFlagsNN::default(), + window: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ViSurfaceCreateInfoNN { + const STRUCTURE_TYPE: StructureType = StructureType::VI_SURFACE_CREATE_INFO_NN; +} +impl ViSurfaceCreateInfoNN { + pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> { + ViSurfaceCreateInfoNNBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ViSurfaceCreateInfoNNBuilder<'a> { + inner: ViSurfaceCreateInfoNN, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> { + type Target = ViSurfaceCreateInfoNN; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn window(mut self, window: *mut c_void) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ViSurfaceCreateInfoNN { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WaylandSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: WaylandSurfaceCreateFlagsKHR, + pub display: *mut wl_display, + pub surface: *mut wl_surface, +} +impl ::std::default::Default for WaylandSurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: WaylandSurfaceCreateFlagsKHR::default(), + display: ::std::ptr::null_mut(), + surface: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for WaylandSurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR; +} +impl WaylandSurfaceCreateInfoKHR { + pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> { + WaylandSurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> { + inner: WaylandSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> { + type Target = WaylandSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: WaylandSurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn display(mut self, display: *mut wl_display) -> Self { + self.inner.display = display; + self + } + #[inline] + pub fn surface(mut self, surface: *mut wl_surface) -> Self { + self.inner.surface = surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WaylandSurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct Win32SurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: Win32SurfaceCreateFlagsKHR, + pub hinstance: HINSTANCE, + pub hwnd: HWND, +} +impl ::std::default::Default for Win32SurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: Win32SurfaceCreateFlagsKHR::default(), + hinstance: unsafe { ::std::mem::zeroed() }, + hwnd: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for Win32SurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::WIN32_SURFACE_CREATE_INFO_KHR; +} +impl Win32SurfaceCreateInfoKHR { + pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> { + Win32SurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Win32SurfaceCreateInfoKHRBuilder<'a> { + inner: Win32SurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> { + type Target = Win32SurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: Win32SurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn hinstance(mut self, hinstance: HINSTANCE) -> Self { + self.inner.hinstance = hinstance; + self + } + #[inline] + pub fn hwnd(mut self, hwnd: HWND) -> Self { + self.inner.hwnd = hwnd; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Win32SurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct XlibSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: XlibSurfaceCreateFlagsKHR, + pub dpy: *mut Display, + pub window: Window, +} +impl ::std::default::Default for XlibSurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: XlibSurfaceCreateFlagsKHR::default(), + dpy: ::std::ptr::null_mut(), + window: Window::default(), + } + } +} +unsafe impl TaggedStructure for XlibSurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::XLIB_SURFACE_CREATE_INFO_KHR; +} +impl XlibSurfaceCreateInfoKHR { + pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> { + XlibSurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct XlibSurfaceCreateInfoKHRBuilder<'a> { + inner: XlibSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> { + type Target = XlibSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: XlibSurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn dpy(mut self, dpy: *mut Display) -> Self { + self.inner.dpy = dpy; + self + } + #[inline] + pub fn window(mut self, window: Window) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> XlibSurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct XcbSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: XcbSurfaceCreateFlagsKHR, + pub connection: *mut xcb_connection_t, + pub window: xcb_window_t, +} +impl ::std::default::Default for XcbSurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: XcbSurfaceCreateFlagsKHR::default(), + connection: ::std::ptr::null_mut(), + window: xcb_window_t::default(), + } + } +} +unsafe impl TaggedStructure for XcbSurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::XCB_SURFACE_CREATE_INFO_KHR; +} +impl XcbSurfaceCreateInfoKHR { + pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> { + XcbSurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct XcbSurfaceCreateInfoKHRBuilder<'a> { + inner: XcbSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> { + type Target = XcbSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn connection(mut self, connection: *mut xcb_connection_t) -> Self { + self.inner.connection = connection; + self + } + #[inline] + pub fn window(mut self, window: xcb_window_t) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> XcbSurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DirectFBSurfaceCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DirectFBSurfaceCreateFlagsEXT, + pub dfb: *mut IDirectFB, + pub surface: *mut IDirectFBSurface, +} +impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DirectFBSurfaceCreateFlagsEXT::default(), + dfb: ::std::ptr::null_mut(), + surface: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DirectFBSurfaceCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT; +} +impl DirectFBSurfaceCreateInfoEXT { + pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + DirectFBSurfaceCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> { + inner: DirectFBSurfaceCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> { + type Target = DirectFBSurfaceCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DirectFBSurfaceCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn dfb(mut self, dfb: *mut IDirectFB) -> Self { + self.inner.dfb = dfb; + self + } + #[inline] + pub fn surface(mut self, surface: *mut IDirectFBSurface) -> Self { + self.inner.surface = surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DirectFBSurfaceCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImagePipeSurfaceCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA, + pub image_pipe_handle: zx_handle_t, +} +impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(), + image_pipe_handle: zx_handle_t::default(), + } + } +} +unsafe impl TaggedStructure for ImagePipeSurfaceCreateInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; +} +impl ImagePipeSurfaceCreateInfoFUCHSIA { + pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + ImagePipeSurfaceCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + inner: ImagePipeSurfaceCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + type Target = ImagePipeSurfaceCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn image_pipe_handle(mut self, image_pipe_handle: zx_handle_t) -> Self { + self.inner.image_pipe_handle = image_pipe_handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct StreamDescriptorSurfaceCreateInfoGGP { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: StreamDescriptorSurfaceCreateFlagsGGP, + pub stream_descriptor: GgpStreamDescriptor, +} +impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: StreamDescriptorSurfaceCreateFlagsGGP::default(), + stream_descriptor: GgpStreamDescriptor::default(), + } + } +} +unsafe impl TaggedStructure for StreamDescriptorSurfaceCreateInfoGGP { + const STRUCTURE_TYPE: StructureType = StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; +} +impl StreamDescriptorSurfaceCreateInfoGGP { + pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + StreamDescriptorSurfaceCreateInfoGGPBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + inner: StreamDescriptorSurfaceCreateInfoGGP, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + type Target = StreamDescriptorSurfaceCreateInfoGGP; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stream_descriptor(mut self, stream_descriptor: GgpStreamDescriptor) -> Self { + self.inner.stream_descriptor = stream_descriptor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> StreamDescriptorSurfaceCreateInfoGGP { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ScreenSurfaceCreateInfoQNX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ScreenSurfaceCreateFlagsQNX, + pub context: *mut _screen_context, + pub window: *mut _screen_window, +} +impl ::std::default::Default for ScreenSurfaceCreateInfoQNX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ScreenSurfaceCreateFlagsQNX::default(), + context: ::std::ptr::null_mut(), + window: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ScreenSurfaceCreateInfoQNX { + const STRUCTURE_TYPE: StructureType = StructureType::SCREEN_SURFACE_CREATE_INFO_QNX; +} +impl ScreenSurfaceCreateInfoQNX { + pub fn builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a> { + ScreenSurfaceCreateInfoQNXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ScreenSurfaceCreateInfoQNXBuilder<'a> { + inner: ScreenSurfaceCreateInfoQNX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ScreenSurfaceCreateInfoQNXBuilder<'a> { + type Target = ScreenSurfaceCreateInfoQNX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ScreenSurfaceCreateInfoQNXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ScreenSurfaceCreateFlagsQNX) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn context(mut self, context: &'a mut _screen_context) -> Self { + self.inner.context = context; + self + } + #[inline] + pub fn window(mut self, window: &'a mut _screen_window) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ScreenSurfaceCreateInfoQNX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct SurfaceFormatKHR { + pub format: Format, + pub color_space: ColorSpaceKHR, +} +impl SurfaceFormatKHR { + pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> { + SurfaceFormatKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceFormatKHRBuilder<'a> { + inner: SurfaceFormatKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> { + type Target = SurfaceFormatKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceFormatKHRBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn color_space(mut self, color_space: ColorSpaceKHR) -> Self { + self.inner.color_space = color_space; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceFormatKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SwapchainCreateFlagsKHR, + pub surface: SurfaceKHR, + pub min_image_count: u32, + pub image_format: Format, + pub image_color_space: ColorSpaceKHR, + pub image_extent: Extent2D, + pub image_array_layers: u32, + pub image_usage: ImageUsageFlags, + pub image_sharing_mode: SharingMode, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, + pub pre_transform: SurfaceTransformFlagsKHR, + pub composite_alpha: CompositeAlphaFlagsKHR, + pub present_mode: PresentModeKHR, + pub clipped: Bool32, + pub old_swapchain: SwapchainKHR, +} +impl ::std::default::Default for SwapchainCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SwapchainCreateFlagsKHR::default(), + surface: SurfaceKHR::default(), + min_image_count: u32::default(), + image_format: Format::default(), + image_color_space: ColorSpaceKHR::default(), + image_extent: Extent2D::default(), + image_array_layers: u32::default(), + image_usage: ImageUsageFlags::default(), + image_sharing_mode: SharingMode::default(), + queue_family_index_count: u32::default(), + p_queue_family_indices: ::std::ptr::null(), + pre_transform: SurfaceTransformFlagsKHR::default(), + composite_alpha: CompositeAlphaFlagsKHR::default(), + present_mode: PresentModeKHR::default(), + clipped: Bool32::default(), + old_swapchain: SwapchainKHR::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_CREATE_INFO_KHR; +} +impl SwapchainCreateInfoKHR { + pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> { + SwapchainCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainCreateInfoKHRBuilder<'a> { + inner: SwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSwapchainCreateInfoKHR {} +impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> { + type Target = SwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn surface(mut self, surface: SurfaceKHR) -> Self { + self.inner.surface = surface; + self + } + #[inline] + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.inner.min_image_count = min_image_count; + self + } + #[inline] + pub fn image_format(mut self, image_format: Format) -> Self { + self.inner.image_format = image_format; + self + } + #[inline] + pub fn image_color_space(mut self, image_color_space: ColorSpaceKHR) -> Self { + self.inner.image_color_space = image_color_space; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent2D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[inline] + pub fn image_array_layers(mut self, image_array_layers: u32) -> Self { + self.inner.image_array_layers = image_array_layers; + self + } + #[inline] + pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self { + self.inner.image_usage = image_usage; + self + } + #[inline] + pub fn image_sharing_mode(mut self, image_sharing_mode: SharingMode) -> Self { + self.inner.image_sharing_mode = image_sharing_mode; + self + } + #[inline] + pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { + self.inner.queue_family_index_count = queue_family_indices.len() as _; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + #[inline] + pub fn pre_transform(mut self, pre_transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.pre_transform = pre_transform; + self + } + #[inline] + pub fn composite_alpha(mut self, composite_alpha: CompositeAlphaFlagsKHR) -> Self { + self.inner.composite_alpha = composite_alpha; + self + } + #[inline] + pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self { + self.inner.present_mode = present_mode; + self + } + #[inline] + pub fn clipped(mut self, clipped: bool) -> Self { + self.inner.clipped = clipped.into(); + self + } + #[inline] + pub fn old_swapchain(mut self, old_swapchain: SwapchainKHR) -> Self { + self.inner.old_swapchain = old_swapchain; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: u32, + pub p_wait_semaphores: *const Semaphore, + pub swapchain_count: u32, + pub p_swapchains: *const SwapchainKHR, + pub p_image_indices: *const u32, + pub p_results: *mut Result, +} +impl ::std::default::Default for PresentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_count: u32::default(), + p_wait_semaphores: ::std::ptr::null(), + swapchain_count: u32::default(), + p_swapchains: ::std::ptr::null(), + p_image_indices: ::std::ptr::null(), + p_results: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for PresentInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_INFO_KHR; +} +impl PresentInfoKHR { + pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> { + PresentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentInfoKHRBuilder<'a> { + inner: PresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPresentInfoKHR {} +impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> { + type Target = PresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentInfoKHRBuilder<'a> { + #[inline] + pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { + self.inner.wait_semaphore_count = wait_semaphores.len() as _; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + #[inline] + pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> Self { + self.inner.swapchain_count = swapchains.len() as _; + self.inner.p_swapchains = swapchains.as_ptr(); + self + } + #[inline] + pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self { + self.inner.swapchain_count = image_indices.len() as _; + self.inner.p_image_indices = image_indices.as_ptr(); + self + } + #[inline] + pub fn results(mut self, results: &'a mut [Result]) -> Self { + self.inner.swapchain_count = results.len() as _; + self.inner.p_results = results.as_mut_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugReportCallbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugReportFlagsEXT, + pub pfn_callback: PFN_vkDebugReportCallbackEXT, + pub p_user_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DebugReportCallbackCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DebugReportCallbackCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("pfn_callback", &(self.pfn_callback.map(|x| x as *const ()))) + .field("p_user_data", &self.p_user_data) + .finish() + } +} +impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DebugReportFlagsEXT::default(), + pfn_callback: PFN_vkDebugReportCallbackEXT::default(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DebugReportCallbackCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; +} +impl DebugReportCallbackCreateInfoEXT { + pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> { + DebugReportCallbackCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> { + inner: DebugReportCallbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> { + type Target = DebugReportCallbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DebugReportFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pfn_callback(mut self, pfn_callback: PFN_vkDebugReportCallbackEXT) -> Self { + self.inner.pfn_callback = pfn_callback; + self + } + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugReportCallbackCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ValidationFlagsEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub disabled_validation_check_count: u32, + pub p_disabled_validation_checks: *const ValidationCheckEXT, +} +impl ::std::default::Default for ValidationFlagsEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + disabled_validation_check_count: u32::default(), + p_disabled_validation_checks: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ValidationFlagsEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_FLAGS_EXT; +} +impl ValidationFlagsEXT { + pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> { + ValidationFlagsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ValidationFlagsEXTBuilder<'a> { + inner: ValidationFlagsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {} +impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> { + type Target = ValidationFlagsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ValidationFlagsEXTBuilder<'a> { + #[inline] + pub fn disabled_validation_checks( + mut self, + disabled_validation_checks: &'a [ValidationCheckEXT], + ) -> Self { + self.inner.disabled_validation_check_count = disabled_validation_checks.len() as _; + self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ValidationFlagsEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ValidationFeaturesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub enabled_validation_feature_count: u32, + pub p_enabled_validation_features: *const ValidationFeatureEnableEXT, + pub disabled_validation_feature_count: u32, + pub p_disabled_validation_features: *const ValidationFeatureDisableEXT, +} +impl ::std::default::Default for ValidationFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + enabled_validation_feature_count: u32::default(), + p_enabled_validation_features: ::std::ptr::null(), + disabled_validation_feature_count: u32::default(), + p_disabled_validation_features: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ValidationFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_FEATURES_EXT; +} +impl ValidationFeaturesEXT { + pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> { + ValidationFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ValidationFeaturesEXTBuilder<'a> { + inner: ValidationFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {} +impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> { + type Target = ValidationFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ValidationFeaturesEXTBuilder<'a> { + #[inline] + pub fn enabled_validation_features( + mut self, + enabled_validation_features: &'a [ValidationFeatureEnableEXT], + ) -> Self { + self.inner.enabled_validation_feature_count = enabled_validation_features.len() as _; + self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr(); + self + } + #[inline] + pub fn disabled_validation_features( + mut self, + disabled_validation_features: &'a [ValidationFeatureDisableEXT], + ) -> Self { + self.inner.disabled_validation_feature_count = disabled_validation_features.len() as _; + self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ValidationFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationStateRasterizationOrderAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub rasterization_order: RasterizationOrderAMD, +} +impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + rasterization_order: RasterizationOrderAMD::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationStateRasterizationOrderAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; +} +impl PipelineRasterizationStateRasterizationOrderAMD { + pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + PipelineRasterizationStateRasterizationOrderAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + inner: PipelineRasterizationStateRasterizationOrderAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateRasterizationOrderAMD +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + type Target = PipelineRasterizationStateRasterizationOrderAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + #[inline] + pub fn rasterization_order(mut self, rasterization_order: RasterizationOrderAMD) -> Self { + self.inner.rasterization_order = rasterization_order; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugMarkerObjectNameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: DebugReportObjectTypeEXT, + pub object: u64, + pub p_object_name: *const c_char, +} +impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + object_type: DebugReportObjectTypeEXT::default(), + object: u64::default(), + p_object_name: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugMarkerObjectNameInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT; +} +impl DebugMarkerObjectNameInfoEXT { + pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> { + DebugMarkerObjectNameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> { + inner: DebugMarkerObjectNameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> { + type Target = DebugMarkerObjectNameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { + #[inline] + pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object(mut self, object: u64) -> Self { + self.inner.object = object; + self + } + #[inline] + pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_object_name = object_name.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugMarkerObjectNameInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugMarkerObjectTagInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: DebugReportObjectTypeEXT, + pub object: u64, + pub tag_name: u64, + pub tag_size: usize, + pub p_tag: *const c_void, +} +impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + object_type: DebugReportObjectTypeEXT::default(), + object: u64::default(), + tag_name: u64::default(), + tag_size: usize::default(), + p_tag: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugMarkerObjectTagInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT; +} +impl DebugMarkerObjectTagInfoEXT { + pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + DebugMarkerObjectTagInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> { + inner: DebugMarkerObjectTagInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> { + type Target = DebugMarkerObjectTagInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { + #[inline] + pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object(mut self, object: u64) -> Self { + self.inner.object = object; + self + } + #[inline] + pub fn tag_name(mut self, tag_name: u64) -> Self { + self.inner.tag_name = tag_name; + self + } + #[inline] + pub fn tag(mut self, tag: &'a [u8]) -> Self { + self.inner.tag_size = tag.len(); + self.inner.p_tag = tag.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugMarkerObjectTagInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugMarkerMarkerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_marker_name: *const c_char, + pub color: [f32; 4], +} +impl ::std::default::Default for DebugMarkerMarkerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_marker_name: ::std::ptr::null(), + color: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for DebugMarkerMarkerInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_MARKER_INFO_EXT; +} +impl DebugMarkerMarkerInfoEXT { + pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> { + DebugMarkerMarkerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugMarkerMarkerInfoEXTBuilder<'a> { + inner: DebugMarkerMarkerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> { + type Target = DebugMarkerMarkerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { + #[inline] + pub fn marker_name(mut self, marker_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_marker_name = marker_name.as_ptr(); + self + } + #[inline] + pub fn color(mut self, color: [f32; 4]) -> Self { + self.inner.color = color; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugMarkerMarkerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DedicatedAllocationImageCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dedicated_allocation: Bool32, +} +impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + dedicated_allocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DedicatedAllocationImageCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; +} +impl DedicatedAllocationImageCreateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> { + DedicatedAllocationImageCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> { + inner: DedicatedAllocationImageCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {} +impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> { + type Target = DedicatedAllocationImageCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> { + #[inline] + pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self { + self.inner.dedicated_allocation = dedicated_allocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DedicatedAllocationImageCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DedicatedAllocationBufferCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dedicated_allocation: Bool32, +} +impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + dedicated_allocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DedicatedAllocationBufferCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; +} +impl DedicatedAllocationBufferCreateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + DedicatedAllocationBufferCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + inner: DedicatedAllocationBufferCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {} +impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + type Target = DedicatedAllocationBufferCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + #[inline] + pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self { + self.inner.dedicated_allocation = dedicated_allocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DedicatedAllocationMemoryAllocateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub buffer: Buffer, +} +impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for DedicatedAllocationMemoryAllocateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; +} +impl DedicatedAllocationMemoryAllocateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + DedicatedAllocationMemoryAllocateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + inner: DedicatedAllocationMemoryAllocateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {} +impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + type Target = DedicatedAllocationMemoryAllocateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ExternalImageFormatPropertiesNV { + pub image_format_properties: ImageFormatProperties, + pub external_memory_features: ExternalMemoryFeatureFlagsNV, + pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, + pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, +} +impl ExternalImageFormatPropertiesNV { + pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> { + ExternalImageFormatPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalImageFormatPropertiesNVBuilder<'a> { + inner: ExternalImageFormatPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> { + type Target = ExternalImageFormatPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> { + #[inline] + pub fn image_format_properties( + mut self, + image_format_properties: ImageFormatProperties, + ) -> Self { + self.inner.image_format_properties = image_format_properties; + self + } + #[inline] + pub fn external_memory_features( + mut self, + external_memory_features: ExternalMemoryFeatureFlagsNV, + ) -> Self { + self.inner.external_memory_features = external_memory_features; + self + } + #[inline] + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + #[inline] + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalImageFormatPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalMemoryImageCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlagsNV, +} +impl ::std::default::Default for ExternalMemoryImageCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for ExternalMemoryImageCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; +} +impl ExternalMemoryImageCreateInfoNV { + pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> { + ExternalMemoryImageCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> { + inner: ExternalMemoryImageCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {} +impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> { + type Target = ExternalMemoryImageCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalMemoryImageCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMemoryAllocateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlagsNV, +} +impl ::std::default::Default for ExportMemoryAllocateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for ExportMemoryAllocateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV; +} +impl ExportMemoryAllocateInfoNV { + pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> { + ExportMemoryAllocateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMemoryAllocateInfoNVBuilder<'a> { + inner: ExportMemoryAllocateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {} +impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> { + type Target = ExportMemoryAllocateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMemoryAllocateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryWin32HandleInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlagsNV, + pub handle: HANDLE, +} +impl ::std::default::Default for ImportMemoryWin32HandleInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlagsNV::default(), + handle: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMemoryWin32HandleInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; +} +impl ImportMemoryWin32HandleInfoNV { + pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> { + ImportMemoryWin32HandleInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> { + inner: ImportMemoryWin32HandleInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {} +impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> { + type Target = ImportMemoryWin32HandleInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlagsNV) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: HANDLE) -> Self { + self.inner.handle = handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryWin32HandleInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMemoryWin32HandleInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, +} +impl ::std::default::Default for ExportMemoryWin32HandleInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), + dw_access: DWORD::default(), + } + } +} +unsafe impl TaggedStructure for ExportMemoryWin32HandleInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; +} +impl ExportMemoryWin32HandleInfoNV { + pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> { + ExportMemoryWin32HandleInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> { + inner: ExportMemoryWin32HandleInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {} +impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> { + type Target = ExportMemoryWin32HandleInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> { + #[inline] + pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { + self.inner.p_attributes = attributes; + self + } + #[inline] + pub fn dw_access(mut self, dw_access: DWORD) -> Self { + self.inner.dw_access = dw_access; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMemoryWin32HandleInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct Win32KeyedMutexAcquireReleaseInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acquire_count: u32, + pub p_acquire_syncs: *const DeviceMemory, + pub p_acquire_keys: *const u64, + pub p_acquire_timeout_milliseconds: *const u32, + pub release_count: u32, + pub p_release_syncs: *const DeviceMemory, + pub p_release_keys: *const u64, +} +impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acquire_count: u32::default(), + p_acquire_syncs: ::std::ptr::null(), + p_acquire_keys: ::std::ptr::null(), + p_acquire_timeout_milliseconds: ::std::ptr::null(), + release_count: u32::default(), + p_release_syncs: ::std::ptr::null(), + p_release_keys: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for Win32KeyedMutexAcquireReleaseInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; +} +impl Win32KeyedMutexAcquireReleaseInfoNV { + pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + Win32KeyedMutexAcquireReleaseInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + inner: Win32KeyedMutexAcquireReleaseInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV {} +impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + type Target = Win32KeyedMutexAcquireReleaseInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + #[inline] + pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self { + self.inner.acquire_count = acquire_syncs.len() as _; + self.inner.p_acquire_syncs = acquire_syncs.as_ptr(); + self + } + #[inline] + pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self { + self.inner.acquire_count = acquire_keys.len() as _; + self.inner.p_acquire_keys = acquire_keys.as_ptr(); + self + } + #[inline] + pub fn acquire_timeout_milliseconds(mut self, acquire_timeout_milliseconds: &'a [u32]) -> Self { + self.inner.acquire_count = acquire_timeout_milliseconds.len() as _; + self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr(); + self + } + #[inline] + pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self { + self.inner.release_count = release_syncs.len() as _; + self.inner.p_release_syncs = release_syncs.as_ptr(); + self + } + #[inline] + pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self { + self.inner.release_count = release_keys.len() as _; + self.inner.p_release_keys = release_keys.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_generated_commands: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_generated_commands: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; +} +impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + #[inline] + pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self { + self.inner.device_generated_commands = device_generated_commands.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DevicePrivateDataCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub private_data_slot_request_count: u32, +} +impl ::std::default::Default for DevicePrivateDataCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + private_data_slot_request_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for DevicePrivateDataCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO; +} +impl DevicePrivateDataCreateInfo { + pub fn builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a> { + DevicePrivateDataCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DevicePrivateDataCreateInfoBuilder<'a> { + inner: DevicePrivateDataCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo {} +impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoBuilder<'a> { + type Target = DevicePrivateDataCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DevicePrivateDataCreateInfoBuilder<'a> { + #[inline] + pub fn private_data_slot_request_count(mut self, private_data_slot_request_count: u32) -> Self { + self.inner.private_data_slot_request_count = private_data_slot_request_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DevicePrivateDataCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PrivateDataSlotCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PrivateDataSlotCreateFlags, +} +impl ::std::default::Default for PrivateDataSlotCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PrivateDataSlotCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for PrivateDataSlotCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PRIVATE_DATA_SLOT_CREATE_INFO; +} +impl PrivateDataSlotCreateInfo { + pub fn builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a> { + PrivateDataSlotCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PrivateDataSlotCreateInfoBuilder<'a> { + inner: PrivateDataSlotCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoBuilder<'a> { + type Target = PrivateDataSlotCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PrivateDataSlotCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PrivateDataSlotCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PrivateDataSlotCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePrivateDataFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub private_data: Bool32, +} +impl ::std::default::Default for PhysicalDevicePrivateDataFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + private_data: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePrivateDataFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; +} +impl PhysicalDevicePrivateDataFeatures { + pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a> { + PhysicalDevicePrivateDataFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePrivateDataFeaturesBuilder<'a> { + inner: PhysicalDevicePrivateDataFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesBuilder<'a> { + type Target = PhysicalDevicePrivateDataFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePrivateDataFeaturesBuilder<'a> { + #[inline] + pub fn private_data(mut self, private_data: bool) -> Self { + self.inner.private_data = private_data.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePrivateDataFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_graphics_shader_group_count: u32, + pub max_indirect_sequence_count: u32, + pub max_indirect_commands_token_count: u32, + pub max_indirect_commands_stream_count: u32, + pub max_indirect_commands_token_offset: u32, + pub max_indirect_commands_stream_stride: u32, + pub min_sequences_count_buffer_offset_alignment: u32, + pub min_sequences_index_buffer_offset_alignment: u32, + pub min_indirect_commands_buffer_offset_alignment: u32, +} +impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_graphics_shader_group_count: u32::default(), + max_indirect_sequence_count: u32::default(), + max_indirect_commands_token_count: u32::default(), + max_indirect_commands_stream_count: u32::default(), + max_indirect_commands_token_offset: u32::default(), + max_indirect_commands_stream_stride: u32::default(), + min_sequences_count_buffer_offset_alignment: u32::default(), + min_sequences_index_buffer_offset_alignment: u32::default(), + min_indirect_commands_buffer_offset_alignment: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; +} +impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + #[inline] + pub fn max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self { + self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count; + self + } + #[inline] + pub fn max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self { + self.inner.max_indirect_sequence_count = max_indirect_sequence_count; + self + } + #[inline] + pub fn max_indirect_commands_token_count( + mut self, + max_indirect_commands_token_count: u32, + ) -> Self { + self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count; + self + } + #[inline] + pub fn max_indirect_commands_stream_count( + mut self, + max_indirect_commands_stream_count: u32, + ) -> Self { + self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count; + self + } + #[inline] + pub fn max_indirect_commands_token_offset( + mut self, + max_indirect_commands_token_offset: u32, + ) -> Self { + self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset; + self + } + #[inline] + pub fn max_indirect_commands_stream_stride( + mut self, + max_indirect_commands_stream_stride: u32, + ) -> Self { + self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride; + self + } + #[inline] + pub fn min_sequences_count_buffer_offset_alignment( + mut self, + min_sequences_count_buffer_offset_alignment: u32, + ) -> Self { + self.inner.min_sequences_count_buffer_offset_alignment = + min_sequences_count_buffer_offset_alignment; + self + } + #[inline] + pub fn min_sequences_index_buffer_offset_alignment( + mut self, + min_sequences_index_buffer_offset_alignment: u32, + ) -> Self { + self.inner.min_sequences_index_buffer_offset_alignment = + min_sequences_index_buffer_offset_alignment; + self + } + #[inline] + pub fn min_indirect_commands_buffer_offset_alignment( + mut self, + min_indirect_commands_buffer_offset_alignment: u32, + ) -> Self { + self.inner.min_indirect_commands_buffer_offset_alignment = + min_indirect_commands_buffer_offset_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiDrawPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_multi_draw_count: u32, +} +impl ::std::default::Default for PhysicalDeviceMultiDrawPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_multi_draw_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiDrawPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; +} +impl PhysicalDeviceMultiDrawPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + PhysicalDeviceMultiDrawPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceMultiDrawPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceMultiDrawPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self { + self.inner.max_multi_draw_count = max_multi_draw_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiDrawPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GraphicsShaderGroupCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, + pub p_tessellation_state: *const PipelineTessellationStateCreateInfo, +} +impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + p_vertex_input_state: ::std::ptr::null(), + p_tessellation_state: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for GraphicsShaderGroupCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV; +} +impl GraphicsShaderGroupCreateInfoNV { + pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> { + GraphicsShaderGroupCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> { + inner: GraphicsShaderGroupCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> { + type Target = GraphicsShaderGroupCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> { + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.inner.stage_count = stages.len() as _; + self.inner.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn vertex_input_state( + mut self, + vertex_input_state: &'a PipelineVertexInputStateCreateInfo, + ) -> Self { + self.inner.p_vertex_input_state = vertex_input_state; + self + } + #[inline] + pub fn tessellation_state( + mut self, + tessellation_state: &'a PipelineTessellationStateCreateInfo, + ) -> Self { + self.inner.p_tessellation_state = tessellation_state; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GraphicsShaderGroupCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GraphicsPipelineShaderGroupsCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub group_count: u32, + pub p_groups: *const GraphicsShaderGroupCreateInfoNV, + pub pipeline_count: u32, + pub p_pipelines: *const Pipeline, +} +impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + group_count: u32::default(), + p_groups: ::std::ptr::null(), + pipeline_count: u32::default(), + p_pipelines: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for GraphicsPipelineShaderGroupsCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; +} +impl GraphicsPipelineShaderGroupsCreateInfoNV { + pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + GraphicsPipelineShaderGroupsCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + inner: GraphicsPipelineShaderGroupsCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV {} +impl<'a> ::std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + type Target = GraphicsPipelineShaderGroupsCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + #[inline] + pub fn groups(mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self { + self.inner.group_count = groups.len() as _; + self.inner.p_groups = groups.as_ptr(); + self + } + #[inline] + pub fn pipelines(mut self, pipelines: &'a [Pipeline]) -> Self { + self.inner.pipeline_count = pipelines.len() as _; + self.inner.p_pipelines = pipelines.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BindShaderGroupIndirectCommandNV { + pub group_index: u32, +} +impl BindShaderGroupIndirectCommandNV { + pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> { + BindShaderGroupIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindShaderGroupIndirectCommandNVBuilder<'a> { + inner: BindShaderGroupIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> { + type Target = BindShaderGroupIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> { + #[inline] + pub fn group_index(mut self, group_index: u32) -> Self { + self.inner.group_index = group_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindShaderGroupIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BindIndexBufferIndirectCommandNV { + pub buffer_address: DeviceAddress, + pub size: u32, + pub index_type: IndexType, +} +impl BindIndexBufferIndirectCommandNV { + pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> { + BindIndexBufferIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindIndexBufferIndirectCommandNVBuilder<'a> { + inner: BindIndexBufferIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> { + type Target = BindIndexBufferIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> { + #[inline] + pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self { + self.inner.buffer_address = buffer_address; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindIndexBufferIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BindVertexBufferIndirectCommandNV { + pub buffer_address: DeviceAddress, + pub size: u32, + pub stride: u32, +} +impl BindVertexBufferIndirectCommandNV { + pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> { + BindVertexBufferIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindVertexBufferIndirectCommandNVBuilder<'a> { + inner: BindVertexBufferIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> { + type Target = BindVertexBufferIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> { + #[inline] + pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self { + self.inner.buffer_address = buffer_address; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn stride(mut self, stride: u32) -> Self { + self.inner.stride = stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindVertexBufferIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SetStateFlagsIndirectCommandNV { + pub data: u32, +} +impl SetStateFlagsIndirectCommandNV { + pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> { + SetStateFlagsIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SetStateFlagsIndirectCommandNVBuilder<'a> { + inner: SetStateFlagsIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> { + type Target = SetStateFlagsIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> { + #[inline] + pub fn data(mut self, data: u32) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SetStateFlagsIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct IndirectCommandsStreamNV { + pub buffer: Buffer, + pub offset: DeviceSize, +} +impl IndirectCommandsStreamNV { + pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> { + IndirectCommandsStreamNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct IndirectCommandsStreamNVBuilder<'a> { + inner: IndirectCommandsStreamNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> { + type Target = IndirectCommandsStreamNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> IndirectCommandsStreamNVBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> IndirectCommandsStreamNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct IndirectCommandsLayoutTokenNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub token_type: IndirectCommandsTokenTypeNV, + pub stream: u32, + pub offset: u32, + pub vertex_binding_unit: u32, + pub vertex_dynamic_stride: Bool32, + pub pushconstant_pipeline_layout: PipelineLayout, + pub pushconstant_shader_stage_flags: ShaderStageFlags, + pub pushconstant_offset: u32, + pub pushconstant_size: u32, + pub indirect_state_flags: IndirectStateFlagsNV, + pub index_type_count: u32, + pub p_index_types: *const IndexType, + pub p_index_type_values: *const u32, +} +impl ::std::default::Default for IndirectCommandsLayoutTokenNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + token_type: IndirectCommandsTokenTypeNV::default(), + stream: u32::default(), + offset: u32::default(), + vertex_binding_unit: u32::default(), + vertex_dynamic_stride: Bool32::default(), + pushconstant_pipeline_layout: PipelineLayout::default(), + pushconstant_shader_stage_flags: ShaderStageFlags::default(), + pushconstant_offset: u32::default(), + pushconstant_size: u32::default(), + indirect_state_flags: IndirectStateFlagsNV::default(), + index_type_count: u32::default(), + p_index_types: ::std::ptr::null(), + p_index_type_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for IndirectCommandsLayoutTokenNV { + const STRUCTURE_TYPE: StructureType = StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV; +} +impl IndirectCommandsLayoutTokenNV { + pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> { + IndirectCommandsLayoutTokenNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct IndirectCommandsLayoutTokenNVBuilder<'a> { + inner: IndirectCommandsLayoutTokenNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> { + type Target = IndirectCommandsLayoutTokenNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> { + #[inline] + pub fn token_type(mut self, token_type: IndirectCommandsTokenTypeNV) -> Self { + self.inner.token_type = token_type; + self + } + #[inline] + pub fn stream(mut self, stream: u32) -> Self { + self.inner.stream = stream; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self { + self.inner.vertex_binding_unit = vertex_binding_unit; + self + } + #[inline] + pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self { + self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into(); + self + } + #[inline] + pub fn pushconstant_pipeline_layout( + mut self, + pushconstant_pipeline_layout: PipelineLayout, + ) -> Self { + self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout; + self + } + #[inline] + pub fn pushconstant_shader_stage_flags( + mut self, + pushconstant_shader_stage_flags: ShaderStageFlags, + ) -> Self { + self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags; + self + } + #[inline] + pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self { + self.inner.pushconstant_offset = pushconstant_offset; + self + } + #[inline] + pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self { + self.inner.pushconstant_size = pushconstant_size; + self + } + #[inline] + pub fn indirect_state_flags(mut self, indirect_state_flags: IndirectStateFlagsNV) -> Self { + self.inner.indirect_state_flags = indirect_state_flags; + self + } + #[inline] + pub fn index_types(mut self, index_types: &'a [IndexType]) -> Self { + self.inner.index_type_count = index_types.len() as _; + self.inner.p_index_types = index_types.as_ptr(); + self + } + #[inline] + pub fn index_type_values(mut self, index_type_values: &'a [u32]) -> Self { + self.inner.index_type_count = index_type_values.len() as _; + self.inner.p_index_type_values = index_type_values.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> IndirectCommandsLayoutTokenNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct IndirectCommandsLayoutCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: IndirectCommandsLayoutUsageFlagsNV, + pub pipeline_bind_point: PipelineBindPoint, + pub token_count: u32, + pub p_tokens: *const IndirectCommandsLayoutTokenNV, + pub stream_count: u32, + pub p_stream_strides: *const u32, +} +impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: IndirectCommandsLayoutUsageFlagsNV::default(), + pipeline_bind_point: PipelineBindPoint::default(), + token_count: u32::default(), + p_tokens: ::std::ptr::null(), + stream_count: u32::default(), + p_stream_strides: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for IndirectCommandsLayoutCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV; +} +impl IndirectCommandsLayoutCreateInfoNV { + pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + IndirectCommandsLayoutCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + inner: IndirectCommandsLayoutCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + type Target = IndirectCommandsLayoutCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: IndirectCommandsLayoutUsageFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn tokens(mut self, tokens: &'a [IndirectCommandsLayoutTokenNV]) -> Self { + self.inner.token_count = tokens.len() as _; + self.inner.p_tokens = tokens.as_ptr(); + self + } + #[inline] + pub fn stream_strides(mut self, stream_strides: &'a [u32]) -> Self { + self.inner.stream_count = stream_strides.len() as _; + self.inner.p_stream_strides = stream_strides.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeneratedCommandsInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline_bind_point: PipelineBindPoint, + pub pipeline: Pipeline, + pub indirect_commands_layout: IndirectCommandsLayoutNV, + pub stream_count: u32, + pub p_streams: *const IndirectCommandsStreamNV, + pub sequences_count: u32, + pub preprocess_buffer: Buffer, + pub preprocess_offset: DeviceSize, + pub preprocess_size: DeviceSize, + pub sequences_count_buffer: Buffer, + pub sequences_count_offset: DeviceSize, + pub sequences_index_buffer: Buffer, + pub sequences_index_offset: DeviceSize, +} +impl ::std::default::Default for GeneratedCommandsInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline_bind_point: PipelineBindPoint::default(), + pipeline: Pipeline::default(), + indirect_commands_layout: IndirectCommandsLayoutNV::default(), + stream_count: u32::default(), + p_streams: ::std::ptr::null(), + sequences_count: u32::default(), + preprocess_buffer: Buffer::default(), + preprocess_offset: DeviceSize::default(), + preprocess_size: DeviceSize::default(), + sequences_count_buffer: Buffer::default(), + sequences_count_offset: DeviceSize::default(), + sequences_index_buffer: Buffer::default(), + sequences_index_offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for GeneratedCommandsInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::GENERATED_COMMANDS_INFO_NV; +} +impl GeneratedCommandsInfoNV { + pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> { + GeneratedCommandsInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeneratedCommandsInfoNVBuilder<'a> { + inner: GeneratedCommandsInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> { + type Target = GeneratedCommandsInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeneratedCommandsInfoNVBuilder<'a> { + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.inner.pipeline = pipeline; + self + } + #[inline] + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: IndirectCommandsLayoutNV, + ) -> Self { + self.inner.indirect_commands_layout = indirect_commands_layout; + self + } + #[inline] + pub fn streams(mut self, streams: &'a [IndirectCommandsStreamNV]) -> Self { + self.inner.stream_count = streams.len() as _; + self.inner.p_streams = streams.as_ptr(); + self + } + #[inline] + pub fn sequences_count(mut self, sequences_count: u32) -> Self { + self.inner.sequences_count = sequences_count; + self + } + #[inline] + pub fn preprocess_buffer(mut self, preprocess_buffer: Buffer) -> Self { + self.inner.preprocess_buffer = preprocess_buffer; + self + } + #[inline] + pub fn preprocess_offset(mut self, preprocess_offset: DeviceSize) -> Self { + self.inner.preprocess_offset = preprocess_offset; + self + } + #[inline] + pub fn preprocess_size(mut self, preprocess_size: DeviceSize) -> Self { + self.inner.preprocess_size = preprocess_size; + self + } + #[inline] + pub fn sequences_count_buffer(mut self, sequences_count_buffer: Buffer) -> Self { + self.inner.sequences_count_buffer = sequences_count_buffer; + self + } + #[inline] + pub fn sequences_count_offset(mut self, sequences_count_offset: DeviceSize) -> Self { + self.inner.sequences_count_offset = sequences_count_offset; + self + } + #[inline] + pub fn sequences_index_buffer(mut self, sequences_index_buffer: Buffer) -> Self { + self.inner.sequences_index_buffer = sequences_index_buffer; + self + } + #[inline] + pub fn sequences_index_offset(mut self, sequences_index_offset: DeviceSize) -> Self { + self.inner.sequences_index_offset = sequences_index_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeneratedCommandsInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeneratedCommandsMemoryRequirementsInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline_bind_point: PipelineBindPoint, + pub pipeline: Pipeline, + pub indirect_commands_layout: IndirectCommandsLayoutNV, + pub max_sequences_count: u32, +} +impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline_bind_point: PipelineBindPoint::default(), + pipeline: Pipeline::default(), + indirect_commands_layout: IndirectCommandsLayoutNV::default(), + max_sequences_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for GeneratedCommandsMemoryRequirementsInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV; +} +impl GeneratedCommandsMemoryRequirementsInfoNV { + pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + GeneratedCommandsMemoryRequirementsInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + inner: GeneratedCommandsMemoryRequirementsInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + type Target = GeneratedCommandsMemoryRequirementsInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.inner.pipeline = pipeline; + self + } + #[inline] + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: IndirectCommandsLayoutNV, + ) -> Self { + self.inner.indirect_commands_layout = indirect_commands_layout; + self + } + #[inline] + pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self { + self.inner.max_sequences_count = max_sequences_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFeatures2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub features: PhysicalDeviceFeatures, +} +impl ::std::default::Default for PhysicalDeviceFeatures2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + features: PhysicalDeviceFeatures::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFeatures2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FEATURES_2; +} +impl PhysicalDeviceFeatures2 { + pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> { + PhysicalDeviceFeatures2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFeatures2Builder<'a> { + inner: PhysicalDeviceFeatures2, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {} +pub unsafe trait ExtendsPhysicalDeviceFeatures2 {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> { + type Target = PhysicalDeviceFeatures2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFeatures2Builder<'a> { + #[inline] + pub fn features(mut self, features: PhysicalDeviceFeatures) -> Self { + self.inner.features = features; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFeatures2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub properties: PhysicalDeviceProperties, +} +impl ::std::default::Default for PhysicalDeviceProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + properties: PhysicalDeviceProperties::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PROPERTIES_2; +} +impl PhysicalDeviceProperties2 { + pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> { + PhysicalDeviceProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProperties2Builder<'a> { + inner: PhysicalDeviceProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceProperties2 {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> { + type Target = PhysicalDeviceProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProperties2Builder<'a> { + #[inline] + pub fn properties(mut self, properties: PhysicalDeviceProperties) -> Self { + self.inner.properties = properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FormatProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_properties: FormatProperties, +} +impl ::std::default::Default for FormatProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format_properties: FormatProperties::default(), + } + } +} +unsafe impl TaggedStructure for FormatProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_2; +} +impl FormatProperties2 { + pub fn builder<'a>() -> FormatProperties2Builder<'a> { + FormatProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FormatProperties2Builder<'a> { + inner: FormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsFormatProperties2 {} +impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> { + type Target = FormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FormatProperties2Builder<'a> { + #[inline] + pub fn format_properties(mut self, format_properties: FormatProperties) -> Self { + self.inner.format_properties = format_properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FormatProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageFormatProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_format_properties: ImageFormatProperties, +} +impl ::std::default::Default for ImageFormatProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_format_properties: ImageFormatProperties::default(), + } + } +} +unsafe impl TaggedStructure for ImageFormatProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_PROPERTIES_2; +} +impl ImageFormatProperties2 { + pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> { + ImageFormatProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatProperties2Builder<'a> { + inner: ImageFormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageFormatProperties2 {} +impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> { + type Target = ImageFormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatProperties2Builder<'a> { + #[inline] + pub fn image_format_properties( + mut self, + image_format_properties: ImageFormatProperties, + ) -> Self { + self.inner.image_format_properties = image_format_properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageFormatInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ty: ImageType, + pub tiling: ImageTiling, + pub usage: ImageUsageFlags, + pub flags: ImageCreateFlags, +} +impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + ty: ImageType::default(), + tiling: ImageTiling::default(), + usage: ImageUsageFlags::default(), + flags: ImageCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageFormatInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; +} +impl PhysicalDeviceImageFormatInfo2 { + pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> { + PhysicalDeviceImageFormatInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageFormatInfo2Builder<'a> { + inner: PhysicalDeviceImageFormatInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> { + type Target = PhysicalDeviceImageFormatInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn ty(mut self, ty: ImageType) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn tiling(mut self, tiling: ImageTiling) -> Self { + self.inner.tiling = tiling; + self + } + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn flags(mut self, flags: ImageCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageFormatInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub queue_family_properties: QueueFamilyProperties, +} +impl ::std::default::Default for QueueFamilyProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + queue_family_properties: QueueFamilyProperties::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_PROPERTIES_2; +} +impl QueueFamilyProperties2 { + pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> { + QueueFamilyProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyProperties2Builder<'a> { + inner: QueueFamilyProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsQueueFamilyProperties2 {} +impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> { + type Target = QueueFamilyProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyProperties2Builder<'a> { + #[inline] + pub fn queue_family_properties( + mut self, + queue_family_properties: QueueFamilyProperties, + ) -> Self { + self.inner.queue_family_properties = queue_family_properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_properties: PhysicalDeviceMemoryProperties, +} +impl ::std::default::Default for PhysicalDeviceMemoryProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_properties: PhysicalDeviceMemoryProperties::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; +} +impl PhysicalDeviceMemoryProperties2 { + pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> { + PhysicalDeviceMemoryProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryProperties2Builder<'a> { + inner: PhysicalDeviceMemoryProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> { + type Target = PhysicalDeviceMemoryProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { + #[inline] + pub fn memory_properties(mut self, memory_properties: PhysicalDeviceMemoryProperties) -> Self { + self.inner.memory_properties = memory_properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseImageFormatProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub properties: SparseImageFormatProperties, +} +impl ::std::default::Default for SparseImageFormatProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + properties: SparseImageFormatProperties::default(), + } + } +} +unsafe impl TaggedStructure for SparseImageFormatProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2; +} +impl SparseImageFormatProperties2 { + pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> { + SparseImageFormatProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageFormatProperties2Builder<'a> { + inner: SparseImageFormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> { + type Target = SparseImageFormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageFormatProperties2Builder<'a> { + #[inline] + pub fn properties(mut self, properties: SparseImageFormatProperties) -> Self { + self.inner.properties = properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageFormatProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSparseImageFormatInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ty: ImageType, + pub samples: SampleCountFlags, + pub usage: ImageUsageFlags, + pub tiling: ImageTiling, +} +impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + ty: ImageType::default(), + samples: SampleCountFlags::default(), + usage: ImageUsageFlags::default(), + tiling: ImageTiling::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSparseImageFormatInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; +} +impl PhysicalDeviceSparseImageFormatInfo2 { + pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + PhysicalDeviceSparseImageFormatInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + inner: PhysicalDeviceSparseImageFormatInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + type Target = PhysicalDeviceSparseImageFormatInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn ty(mut self, ty: ImageType) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn samples(mut self, samples: SampleCountFlags) -> Self { + self.inner.samples = samples; + self + } + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn tiling(mut self, tiling: ImageTiling) -> Self { + self.inner.tiling = tiling; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePushDescriptorPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_push_descriptors: u32, +} +impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_push_descriptors: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePushDescriptorPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR; +} +impl PhysicalDevicePushDescriptorPropertiesKHR { + pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + PhysicalDevicePushDescriptorPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + inner: PhysicalDevicePushDescriptorPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + type Target = PhysicalDevicePushDescriptorPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + #[inline] + pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self { + self.inner.max_push_descriptors = max_push_descriptors; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ConformanceVersion { + pub major: u8, + pub minor: u8, + pub subminor: u8, + pub patch: u8, +} +impl ConformanceVersion { + pub fn builder<'a>() -> ConformanceVersionBuilder<'a> { + ConformanceVersionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ConformanceVersionBuilder<'a> { + inner: ConformanceVersion, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ConformanceVersionBuilder<'a> { + type Target = ConformanceVersion; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ConformanceVersionBuilder<'a> { + #[inline] + pub fn major(mut self, major: u8) -> Self { + self.inner.major = major; + self + } + #[inline] + pub fn minor(mut self, minor: u8) -> Self { + self.inner.minor = minor; + self + } + #[inline] + pub fn subminor(mut self, subminor: u8) -> Self { + self.inner.subminor = subminor; + self + } + #[inline] + pub fn patch(mut self, patch: u8) -> Self { + self.inner.patch = patch; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ConformanceVersion { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDriverProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub driver_id: DriverId, + pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE], + pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE], + pub conformance_version: ConformanceVersion, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PhysicalDeviceDriverProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PhysicalDeviceDriverProperties") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("driver_id", &self.driver_id) + .field("driver_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr()) + }) + .field("driver_info", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr()) + }) + .field("conformance_version", &self.conformance_version) + .finish() + } +} +impl ::std::default::Default for PhysicalDeviceDriverProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + driver_id: DriverId::default(), + driver_name: unsafe { ::std::mem::zeroed() }, + driver_info: unsafe { ::std::mem::zeroed() }, + conformance_version: ConformanceVersion::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDriverProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES; +} +impl PhysicalDeviceDriverProperties { + pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> { + PhysicalDeviceDriverPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDriverPropertiesBuilder<'a> { + inner: PhysicalDeviceDriverProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> { + type Target = PhysicalDeviceDriverProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> { + #[inline] + pub fn driver_id(mut self, driver_id: DriverId) -> Self { + self.inner.driver_id = driver_id; + self + } + #[inline] + pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self { + self.inner.driver_name = driver_name; + self + } + #[inline] + pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self { + self.inner.driver_info = driver_info; + self + } + #[inline] + pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self { + self.inner.conformance_version = conformance_version; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDriverProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentRegionsKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_regions: *const PresentRegionKHR, +} +impl ::std::default::Default for PresentRegionsKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PresentRegionsKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_REGIONS_KHR; +} +impl PresentRegionsKHR { + pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> { + PresentRegionsKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentRegionsKHRBuilder<'a> { + inner: PresentRegionsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {} +impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> { + type Target = PresentRegionsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentRegionsKHRBuilder<'a> { + #[inline] + pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> Self { + self.inner.swapchain_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentRegionsKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentRegionKHR { + pub rectangle_count: u32, + pub p_rectangles: *const RectLayerKHR, +} +impl ::std::default::Default for PresentRegionKHR { + #[inline] + fn default() -> Self { + Self { + rectangle_count: u32::default(), + p_rectangles: ::std::ptr::null(), + } + } +} +impl PresentRegionKHR { + pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> { + PresentRegionKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentRegionKHRBuilder<'a> { + inner: PresentRegionKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> { + type Target = PresentRegionKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentRegionKHRBuilder<'a> { + #[inline] + pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> Self { + self.inner.rectangle_count = rectangles.len() as _; + self.inner.p_rectangles = rectangles.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentRegionKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct RectLayerKHR { + pub offset: Offset2D, + pub extent: Extent2D, + pub layer: u32, +} +impl RectLayerKHR { + pub fn builder<'a>() -> RectLayerKHRBuilder<'a> { + RectLayerKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RectLayerKHRBuilder<'a> { + inner: RectLayerKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> { + type Target = RectLayerKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RectLayerKHRBuilder<'a> { + #[inline] + pub fn offset(mut self, offset: Offset2D) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent2D) -> Self { + self.inner.extent = extent; + self + } + #[inline] + pub fn layer(mut self, layer: u32) -> Self { + self.inner.layer = layer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RectLayerKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVariablePointersFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub variable_pointers_storage_buffer: Bool32, + pub variable_pointers: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + variable_pointers_storage_buffer: Bool32::default(), + variable_pointers: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVariablePointersFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; +} +impl PhysicalDeviceVariablePointersFeatures { + pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + PhysicalDeviceVariablePointersFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + inner: PhysicalDeviceVariablePointersFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + type Target = PhysicalDeviceVariablePointersFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + #[inline] + pub fn variable_pointers_storage_buffer( + mut self, + variable_pointers_storage_buffer: bool, + ) -> Self { + self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into(); + self + } + #[inline] + pub fn variable_pointers(mut self, variable_pointers: bool) -> Self { + self.inner.variable_pointers = variable_pointers.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVariablePointersFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ExternalMemoryProperties { + pub external_memory_features: ExternalMemoryFeatureFlags, + pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, + pub compatible_handle_types: ExternalMemoryHandleTypeFlags, +} +impl ExternalMemoryProperties { + pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> { + ExternalMemoryPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalMemoryPropertiesBuilder<'a> { + inner: ExternalMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> { + type Target = ExternalMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalMemoryPropertiesBuilder<'a> { + #[inline] + pub fn external_memory_features( + mut self, + external_memory_features: ExternalMemoryFeatureFlags, + ) -> Self { + self.inner.external_memory_features = external_memory_features; + self + } + #[inline] + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, + ) -> Self { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + #[inline] + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalMemoryHandleTypeFlags, + ) -> Self { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalMemoryProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalImageFormatInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalImageFormatInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; +} +impl PhysicalDeviceExternalImageFormatInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + PhysicalDeviceExternalImageFormatInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + inner: PhysicalDeviceExternalImageFormatInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 + for PhysicalDeviceExternalImageFormatInfoBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + type Target = PhysicalDeviceExternalImageFormatInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalImageFormatProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_memory_properties: ExternalMemoryProperties, +} +impl ::std::default::Default for ExternalImageFormatProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_memory_properties: ExternalMemoryProperties::default(), + } + } +} +unsafe impl TaggedStructure for ExternalImageFormatProperties { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES; +} +impl ExternalImageFormatProperties { + pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> { + ExternalImageFormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalImageFormatPropertiesBuilder<'a> { + inner: ExternalImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {} +impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> { + type Target = ExternalImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalImageFormatPropertiesBuilder<'a> { + #[inline] + pub fn external_memory_properties( + mut self, + external_memory_properties: ExternalMemoryProperties, + ) -> Self { + self.inner.external_memory_properties = external_memory_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalImageFormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalBufferInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferCreateFlags, + pub usage: BufferUsageFlags, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for PhysicalDeviceExternalBufferInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: BufferCreateFlags::default(), + usage: BufferUsageFlags::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalBufferInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; +} +impl PhysicalDeviceExternalBufferInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> { + PhysicalDeviceExternalBufferInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> { + inner: PhysicalDeviceExternalBufferInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> { + type Target = PhysicalDeviceExternalBufferInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: BufferCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalBufferInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalBufferProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_memory_properties: ExternalMemoryProperties, +} +impl ::std::default::Default for ExternalBufferProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_memory_properties: ExternalMemoryProperties::default(), + } + } +} +unsafe impl TaggedStructure for ExternalBufferProperties { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_BUFFER_PROPERTIES; +} +impl ExternalBufferProperties { + pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> { + ExternalBufferPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalBufferPropertiesBuilder<'a> { + inner: ExternalBufferProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> { + type Target = ExternalBufferProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalBufferPropertiesBuilder<'a> { + #[inline] + pub fn external_memory_properties( + mut self, + external_memory_properties: ExternalMemoryProperties, + ) -> Self { + self.inner.external_memory_properties = external_memory_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalBufferProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceIDProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_uuid: [u8; UUID_SIZE], + pub driver_uuid: [u8; UUID_SIZE], + pub device_luid: [u8; LUID_SIZE], + pub device_node_mask: u32, + pub device_luid_valid: Bool32, +} +impl ::std::default::Default for PhysicalDeviceIDProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_uuid: unsafe { ::std::mem::zeroed() }, + driver_uuid: unsafe { ::std::mem::zeroed() }, + device_luid: unsafe { ::std::mem::zeroed() }, + device_node_mask: u32::default(), + device_luid_valid: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceIDProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ID_PROPERTIES; +} +impl PhysicalDeviceIDProperties { + pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> { + PhysicalDeviceIDPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceIDPropertiesBuilder<'a> { + inner: PhysicalDeviceIDProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> { + type Target = PhysicalDeviceIDProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> { + #[inline] + pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.device_uuid = device_uuid; + self + } + #[inline] + pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.driver_uuid = driver_uuid; + self + } + #[inline] + pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self { + self.inner.device_luid = device_luid; + self + } + #[inline] + pub fn device_node_mask(mut self, device_node_mask: u32) -> Self { + self.inner.device_node_mask = device_node_mask; + self + } + #[inline] + pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self { + self.inner.device_luid_valid = device_luid_valid.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceIDProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalMemoryImageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for ExternalMemoryImageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExternalMemoryImageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO; +} +impl ExternalMemoryImageCreateInfo { + pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> { + ExternalMemoryImageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalMemoryImageCreateInfoBuilder<'a> { + inner: ExternalMemoryImageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {} +impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> { + type Target = ExternalMemoryImageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalMemoryImageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalMemoryBufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for ExternalMemoryBufferCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExternalMemoryBufferCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO; +} +impl ExternalMemoryBufferCreateInfo { + pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> { + ExternalMemoryBufferCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalMemoryBufferCreateInfoBuilder<'a> { + inner: ExternalMemoryBufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {} +impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> { + type Target = ExternalMemoryBufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalMemoryBufferCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMemoryAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for ExportMemoryAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExportMemoryAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_ALLOCATE_INFO; +} +impl ExportMemoryAllocateInfo { + pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> { + ExportMemoryAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMemoryAllocateInfoBuilder<'a> { + inner: ExportMemoryAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {} +impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> { + type Target = ExportMemoryAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMemoryAllocateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMemoryAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMemoryWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; +} +impl ImportMemoryWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + ImportMemoryWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> { + inner: ImportMemoryWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {} +impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> { + type Target = ImportMemoryWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: HANDLE) -> Self { + self.inner.handle = handle; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMemoryWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMemoryWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; +} +impl ExportMemoryWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + ExportMemoryWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> { + inner: ExportMemoryWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {} +impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> { + type Target = ExportMemoryWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { + self.inner.p_attributes = attributes; + self + } + #[inline] + pub fn dw_access(mut self, dw_access: DWORD) -> Self { + self.inner.dw_access = dw_access; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMemoryWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryZirconHandleInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub handle: zx_handle_t, +} +impl ::std::default::Default for ImportMemoryZirconHandleInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + handle: zx_handle_t::default(), + } + } +} +unsafe impl TaggedStructure for ImportMemoryZirconHandleInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; +} +impl ImportMemoryZirconHandleInfoFUCHSIA { + pub fn builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + ImportMemoryZirconHandleInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + inner: ImportMemoryZirconHandleInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIABuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIA {} +impl<'a> ::std::ops::Deref for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + type Target = ImportMemoryZirconHandleInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: zx_handle_t) -> Self { + self.inner.handle = handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryZirconHandleInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryZirconHandlePropertiesFUCHSIA { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, +} +impl ::std::default::Default for MemoryZirconHandlePropertiesFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryZirconHandlePropertiesFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; +} +impl MemoryZirconHandlePropertiesFUCHSIA { + pub fn builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + MemoryZirconHandlePropertiesFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + inner: MemoryZirconHandlePropertiesFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + type Target = MemoryZirconHandlePropertiesFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryZirconHandlePropertiesFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetZirconHandleInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for MemoryGetZirconHandleInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetZirconHandleInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; +} +impl MemoryGetZirconHandleInfoFUCHSIA { + pub fn builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + MemoryGetZirconHandleInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + inner: MemoryGetZirconHandleInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + type Target = MemoryGetZirconHandleInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetZirconHandleInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryWin32HandlePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, +} +impl ::std::default::Default for MemoryWin32HandlePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryWin32HandlePropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR; +} +impl MemoryWin32HandlePropertiesKHR { + pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> { + MemoryWin32HandlePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> { + inner: MemoryWin32HandlePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> { + type Target = MemoryWin32HandlePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryWin32HandlePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for MemoryGetWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR; +} +impl MemoryGetWin32HandleInfoKHR { + pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> { + MemoryGetWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> { + inner: MemoryGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> { + type Target = MemoryGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub fd: c_int, +} +impl ::std::default::Default for ImportMemoryFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} +unsafe impl TaggedStructure for ImportMemoryFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_FD_INFO_KHR; +} +impl ImportMemoryFdInfoKHR { + pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> { + ImportMemoryFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryFdInfoKHRBuilder<'a> { + inner: ImportMemoryFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {} +impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> { + type Target = ImportMemoryFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryFdInfoKHRBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn fd(mut self, fd: c_int) -> Self { + self.inner.fd = fd; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryFdPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, +} +impl ::std::default::Default for MemoryFdPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryFdPropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_FD_PROPERTIES_KHR; +} +impl MemoryFdPropertiesKHR { + pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> { + MemoryFdPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryFdPropertiesKHRBuilder<'a> { + inner: MemoryFdPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> { + type Target = MemoryFdPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryFdPropertiesKHRBuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryFdPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for MemoryGetFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_FD_INFO_KHR; +} +impl MemoryGetFdInfoKHR { + pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> { + MemoryGetFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetFdInfoKHRBuilder<'a> { + inner: MemoryGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> { + type Target = MemoryGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetFdInfoKHRBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct Win32KeyedMutexAcquireReleaseInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acquire_count: u32, + pub p_acquire_syncs: *const DeviceMemory, + pub p_acquire_keys: *const u64, + pub p_acquire_timeouts: *const u32, + pub release_count: u32, + pub p_release_syncs: *const DeviceMemory, + pub p_release_keys: *const u64, +} +impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acquire_count: u32::default(), + p_acquire_syncs: ::std::ptr::null(), + p_acquire_keys: ::std::ptr::null(), + p_acquire_timeouts: ::std::ptr::null(), + release_count: u32::default(), + p_release_syncs: ::std::ptr::null(), + p_release_keys: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for Win32KeyedMutexAcquireReleaseInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; +} +impl Win32KeyedMutexAcquireReleaseInfoKHR { + pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + Win32KeyedMutexAcquireReleaseInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + inner: Win32KeyedMutexAcquireReleaseInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR {} +impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + type Target = Win32KeyedMutexAcquireReleaseInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + #[inline] + pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self { + self.inner.acquire_count = acquire_syncs.len() as _; + self.inner.p_acquire_syncs = acquire_syncs.as_ptr(); + self + } + #[inline] + pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self { + self.inner.acquire_count = acquire_keys.len() as _; + self.inner.p_acquire_keys = acquire_keys.as_ptr(); + self + } + #[inline] + pub fn acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self { + self.inner.acquire_count = acquire_timeouts.len() as _; + self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr(); + self + } + #[inline] + pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self { + self.inner.release_count = release_syncs.len() as _; + self.inner.p_release_syncs = release_syncs.as_ptr(); + self + } + #[inline] + pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self { + self.inner.release_count = release_keys.len() as _; + self.inner.p_release_keys = release_keys.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalSemaphoreInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalSemaphoreInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; +} +impl PhysicalDeviceExternalSemaphoreInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + PhysicalDeviceExternalSemaphoreInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + inner: PhysicalDeviceExternalSemaphoreInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + type Target = PhysicalDeviceExternalSemaphoreInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalSemaphoreProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, + pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags, + pub external_semaphore_features: ExternalSemaphoreFeatureFlags, +} +impl ::std::default::Default for ExternalSemaphoreProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(), + compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(), + external_semaphore_features: ExternalSemaphoreFeatureFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExternalSemaphoreProperties { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_SEMAPHORE_PROPERTIES; +} +impl ExternalSemaphoreProperties { + pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> { + ExternalSemaphorePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalSemaphorePropertiesBuilder<'a> { + inner: ExternalSemaphoreProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> { + type Target = ExternalSemaphoreProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalSemaphorePropertiesBuilder<'a> { + #[inline] + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, + ) -> Self { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + #[inline] + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalSemaphoreHandleTypeFlags, + ) -> Self { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + #[inline] + pub fn external_semaphore_features( + mut self, + external_semaphore_features: ExternalSemaphoreFeatureFlags, + ) -> Self { + self.inner.external_semaphore_features = external_semaphore_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalSemaphoreProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportSemaphoreCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for ExportSemaphoreCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExportSemaphoreCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_SEMAPHORE_CREATE_INFO; +} +impl ExportSemaphoreCreateInfo { + pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> { + ExportSemaphoreCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportSemaphoreCreateInfoBuilder<'a> { + inner: ExportSemaphoreCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {} +impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> { + type Target = ExportSemaphoreCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportSemaphoreCreateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportSemaphoreCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportSemaphoreWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub flags: SemaphoreImportFlags, + pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + flags: SemaphoreImportFlags::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportSemaphoreWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; +} +impl ImportSemaphoreWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + ImportSemaphoreWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + inner: ImportSemaphoreWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + type Target = ImportSemaphoreWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: HANDLE) -> Self { + self.inner.handle = handle; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportSemaphoreWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportSemaphoreWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; +} +impl ExportSemaphoreWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + ExportSemaphoreWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + inner: ExportSemaphoreWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {} +impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + type Target = ExportSemaphoreWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { + self.inner.p_attributes = attributes; + self + } + #[inline] + pub fn dw_access(mut self, dw_access: DWORD) -> Self { + self.inner.dw_access = dw_access; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct D3D12FenceSubmitInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_values_count: u32, + pub p_wait_semaphore_values: *const u64, + pub signal_semaphore_values_count: u32, + pub p_signal_semaphore_values: *const u64, +} +impl ::std::default::Default for D3D12FenceSubmitInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_values_count: u32::default(), + p_wait_semaphore_values: ::std::ptr::null(), + signal_semaphore_values_count: u32::default(), + p_signal_semaphore_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for D3D12FenceSubmitInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::D3D12_FENCE_SUBMIT_INFO_KHR; +} +impl D3D12FenceSubmitInfoKHR { + pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> { + D3D12FenceSubmitInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct D3D12FenceSubmitInfoKHRBuilder<'a> { + inner: D3D12FenceSubmitInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {} +impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> { + type Target = D3D12FenceSubmitInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> { + #[inline] + pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self { + self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _; + self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); + self + } + #[inline] + pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self { + self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _; + self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> D3D12FenceSubmitInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreGetWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; +} +impl SemaphoreGetWin32HandleInfoKHR { + pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + SemaphoreGetWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + inner: SemaphoreGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + type Target = SemaphoreGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportSemaphoreFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub flags: SemaphoreImportFlags, + pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub fd: c_int, +} +impl ::std::default::Default for ImportSemaphoreFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + flags: SemaphoreImportFlags::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} +unsafe impl TaggedStructure for ImportSemaphoreFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR; +} +impl ImportSemaphoreFdInfoKHR { + pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> { + ImportSemaphoreFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportSemaphoreFdInfoKHRBuilder<'a> { + inner: ImportSemaphoreFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> { + type Target = ImportSemaphoreFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn fd(mut self, fd: c_int) -> Self { + self.inner.fd = fd; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportSemaphoreFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for SemaphoreGetFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreGetFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_FD_INFO_KHR; +} +impl SemaphoreGetFdInfoKHR { + pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> { + SemaphoreGetFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreGetFdInfoKHRBuilder<'a> { + inner: SemaphoreGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> { + type Target = SemaphoreGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreGetFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportSemaphoreZirconHandleInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub flags: SemaphoreImportFlags, + pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub zircon_handle: zx_handle_t, +} +impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + flags: SemaphoreImportFlags::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + zircon_handle: zx_handle_t::default(), + } + } +} +unsafe impl TaggedStructure for ImportSemaphoreZirconHandleInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = + StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; +} +impl ImportSemaphoreZirconHandleInfoFUCHSIA { + pub fn builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + ImportSemaphoreZirconHandleInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + inner: ImportSemaphoreZirconHandleInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + type Target = ImportSemaphoreZirconHandleInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn zircon_handle(mut self, zircon_handle: zx_handle_t) -> Self { + self.inner.zircon_handle = zircon_handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportSemaphoreZirconHandleInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreGetZirconHandleInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for SemaphoreGetZirconHandleInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreGetZirconHandleInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; +} +impl SemaphoreGetZirconHandleInfoFUCHSIA { + pub fn builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + SemaphoreGetZirconHandleInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + inner: SemaphoreGetZirconHandleInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + type Target = SemaphoreGetZirconHandleInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreGetZirconHandleInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalFenceInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalFenceHandleTypeFlags, +} +impl ::std::default::Default for PhysicalDeviceExternalFenceInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalFenceInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; +} +impl PhysicalDeviceExternalFenceInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> { + PhysicalDeviceExternalFenceInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> { + inner: PhysicalDeviceExternalFenceInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> { + type Target = PhysicalDeviceExternalFenceInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalFenceInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalFenceProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags, + pub compatible_handle_types: ExternalFenceHandleTypeFlags, + pub external_fence_features: ExternalFenceFeatureFlags, +} +impl ::std::default::Default for ExternalFenceProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(), + compatible_handle_types: ExternalFenceHandleTypeFlags::default(), + external_fence_features: ExternalFenceFeatureFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExternalFenceProperties { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FENCE_PROPERTIES; +} +impl ExternalFenceProperties { + pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> { + ExternalFencePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalFencePropertiesBuilder<'a> { + inner: ExternalFenceProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> { + type Target = ExternalFenceProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalFencePropertiesBuilder<'a> { + #[inline] + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalFenceHandleTypeFlags, + ) -> Self { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + #[inline] + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalFenceHandleTypeFlags, + ) -> Self { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + #[inline] + pub fn external_fence_features( + mut self, + external_fence_features: ExternalFenceFeatureFlags, + ) -> Self { + self.inner.external_fence_features = external_fence_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalFenceProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportFenceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalFenceHandleTypeFlags, +} +impl ::std::default::Default for ExportFenceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalFenceHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExportFenceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_FENCE_CREATE_INFO; +} +impl ExportFenceCreateInfo { + pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> { + ExportFenceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportFenceCreateInfoBuilder<'a> { + inner: ExportFenceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {} +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {} +impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> { + type Target = ExportFenceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportFenceCreateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportFenceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportFenceWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub flags: FenceImportFlags, + pub handle_type: ExternalFenceHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +impl ::std::default::Default for ImportFenceWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fence: Fence::default(), + flags: FenceImportFlags::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportFenceWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; +} +impl ImportFenceWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + ImportFenceWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> { + inner: ImportFenceWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> { + type Target = ImportFenceWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn flags(mut self, flags: FenceImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: HANDLE) -> Self { + self.inner.handle = handle; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportFenceWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportFenceWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +impl ::std::default::Default for ExportFenceWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportFenceWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; +} +impl ExportFenceWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> { + ExportFenceWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> { + inner: ExportFenceWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {} +impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> { + type Target = ExportFenceWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { + self.inner.p_attributes = attributes; + self + } + #[inline] + pub fn dw_access(mut self, dw_access: DWORD) -> Self { + self.inner.dw_access = dw_access; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportFenceWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FenceGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub handle_type: ExternalFenceHandleTypeFlags, +} +impl ::std::default::Default for FenceGetWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fence: Fence::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for FenceGetWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR; +} +impl FenceGetWin32HandleInfoKHR { + pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> { + FenceGetWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FenceGetWin32HandleInfoKHRBuilder<'a> { + inner: FenceGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> { + type Target = FenceGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FenceGetWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportFenceFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub flags: FenceImportFlags, + pub handle_type: ExternalFenceHandleTypeFlags, + pub fd: c_int, +} +impl ::std::default::Default for ImportFenceFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fence: Fence::default(), + flags: FenceImportFlags::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} +unsafe impl TaggedStructure for ImportFenceFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_FENCE_FD_INFO_KHR; +} +impl ImportFenceFdInfoKHR { + pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> { + ImportFenceFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportFenceFdInfoKHRBuilder<'a> { + inner: ImportFenceFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> { + type Target = ImportFenceFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportFenceFdInfoKHRBuilder<'a> { + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn flags(mut self, flags: FenceImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn fd(mut self, fd: c_int) -> Self { + self.inner.fd = fd; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportFenceFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FenceGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub handle_type: ExternalFenceHandleTypeFlags, +} +impl ::std::default::Default for FenceGetFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fence: Fence::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for FenceGetFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::FENCE_GET_FD_INFO_KHR; +} +impl FenceGetFdInfoKHR { + pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> { + FenceGetFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FenceGetFdInfoKHRBuilder<'a> { + inner: FenceGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> { + type Target = FenceGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FenceGetFdInfoKHRBuilder<'a> { + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FenceGetFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multiview: Bool32, + pub multiview_geometry_shader: Bool32, + pub multiview_tessellation_shader: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multiview: Bool32::default(), + multiview_geometry_shader: Bool32::default(), + multiview_tessellation_shader: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiviewFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES; +} +impl PhysicalDeviceMultiviewFeatures { + pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + PhysicalDeviceMultiviewFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> { + inner: PhysicalDeviceMultiviewFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> { + type Target = PhysicalDeviceMultiviewFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + #[inline] + pub fn multiview(mut self, multiview: bool) -> Self { + self.inner.multiview = multiview.into(); + self + } + #[inline] + pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self { + self.inner.multiview_geometry_shader = multiview_geometry_shader.into(); + self + } + #[inline] + pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self { + self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiviewFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_multiview_view_count: u32, + pub max_multiview_instance_index: u32, +} +impl ::std::default::Default for PhysicalDeviceMultiviewProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_multiview_view_count: u32::default(), + max_multiview_instance_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiviewProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; +} +impl PhysicalDeviceMultiviewProperties { + pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> { + PhysicalDeviceMultiviewPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> { + inner: PhysicalDeviceMultiviewProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> { + type Target = PhysicalDeviceMultiviewProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> { + #[inline] + pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self { + self.inner.max_multiview_view_count = max_multiview_view_count; + self + } + #[inline] + pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self { + self.inner.max_multiview_instance_index = max_multiview_instance_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiviewProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassMultiviewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub subpass_count: u32, + pub p_view_masks: *const u32, + pub dependency_count: u32, + pub p_view_offsets: *const i32, + pub correlation_mask_count: u32, + pub p_correlation_masks: *const u32, +} +impl ::std::default::Default for RenderPassMultiviewCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + subpass_count: u32::default(), + p_view_masks: ::std::ptr::null(), + dependency_count: u32::default(), + p_view_offsets: ::std::ptr::null(), + correlation_mask_count: u32::default(), + p_correlation_masks: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassMultiviewCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO; +} +impl RenderPassMultiviewCreateInfo { + pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> { + RenderPassMultiviewCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassMultiviewCreateInfoBuilder<'a> { + inner: RenderPassMultiviewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {} +impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> { + type Target = RenderPassMultiviewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> { + #[inline] + pub fn view_masks(mut self, view_masks: &'a [u32]) -> Self { + self.inner.subpass_count = view_masks.len() as _; + self.inner.p_view_masks = view_masks.as_ptr(); + self + } + #[inline] + pub fn view_offsets(mut self, view_offsets: &'a [i32]) -> Self { + self.inner.dependency_count = view_offsets.len() as _; + self.inner.p_view_offsets = view_offsets.as_ptr(); + self + } + #[inline] + pub fn correlation_masks(mut self, correlation_masks: &'a [u32]) -> Self { + self.inner.correlation_mask_count = correlation_masks.len() as _; + self.inner.p_correlation_masks = correlation_masks.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassMultiviewCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilities2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_image_count: u32, + pub max_image_count: u32, + pub current_extent: Extent2D, + pub min_image_extent: Extent2D, + pub max_image_extent: Extent2D, + pub max_image_array_layers: u32, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub current_transform: SurfaceTransformFlagsKHR, + pub supported_composite_alpha: CompositeAlphaFlagsKHR, + pub supported_usage_flags: ImageUsageFlags, + pub supported_surface_counters: SurfaceCounterFlagsEXT, +} +impl ::std::default::Default for SurfaceCapabilities2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_image_count: u32::default(), + max_image_count: u32::default(), + current_extent: Extent2D::default(), + min_image_extent: Extent2D::default(), + max_image_extent: Extent2D::default(), + max_image_array_layers: u32::default(), + supported_transforms: SurfaceTransformFlagsKHR::default(), + current_transform: SurfaceTransformFlagsKHR::default(), + supported_composite_alpha: CompositeAlphaFlagsKHR::default(), + supported_usage_flags: ImageUsageFlags::default(), + supported_surface_counters: SurfaceCounterFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceCapabilities2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_2_EXT; +} +impl SurfaceCapabilities2EXT { + pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> { + SurfaceCapabilities2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilities2EXTBuilder<'a> { + inner: SurfaceCapabilities2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> { + type Target = SurfaceCapabilities2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilities2EXTBuilder<'a> { + #[inline] + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.inner.min_image_count = min_image_count; + self + } + #[inline] + pub fn max_image_count(mut self, max_image_count: u32) -> Self { + self.inner.max_image_count = max_image_count; + self + } + #[inline] + pub fn current_extent(mut self, current_extent: Extent2D) -> Self { + self.inner.current_extent = current_extent; + self + } + #[inline] + pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self { + self.inner.min_image_extent = min_image_extent; + self + } + #[inline] + pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self { + self.inner.max_image_extent = max_image_extent; + self + } + #[inline] + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + #[inline] + pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { + self.inner.supported_transforms = supported_transforms; + self + } + #[inline] + pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.current_transform = current_transform; + self + } + #[inline] + pub fn supported_composite_alpha( + mut self, + supported_composite_alpha: CompositeAlphaFlagsKHR, + ) -> Self { + self.inner.supported_composite_alpha = supported_composite_alpha; + self + } + #[inline] + pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self { + self.inner.supported_usage_flags = supported_usage_flags; + self + } + #[inline] + pub fn supported_surface_counters( + mut self, + supported_surface_counters: SurfaceCounterFlagsEXT, + ) -> Self { + self.inner.supported_surface_counters = supported_surface_counters; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilities2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPowerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub power_state: DisplayPowerStateEXT, +} +impl ::std::default::Default for DisplayPowerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + power_state: DisplayPowerStateEXT::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPowerInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_POWER_INFO_EXT; +} +impl DisplayPowerInfoEXT { + pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> { + DisplayPowerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPowerInfoEXTBuilder<'a> { + inner: DisplayPowerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> { + type Target = DisplayPowerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPowerInfoEXTBuilder<'a> { + #[inline] + pub fn power_state(mut self, power_state: DisplayPowerStateEXT) -> Self { + self.inner.power_state = power_state; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPowerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_event: DeviceEventTypeEXT, +} +impl ::std::default::Default for DeviceEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_event: DeviceEventTypeEXT::default(), + } + } +} +unsafe impl TaggedStructure for DeviceEventInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_EVENT_INFO_EXT; +} +impl DeviceEventInfoEXT { + pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> { + DeviceEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceEventInfoEXTBuilder<'a> { + inner: DeviceEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> { + type Target = DeviceEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceEventInfoEXTBuilder<'a> { + #[inline] + pub fn device_event(mut self, device_event: DeviceEventTypeEXT) -> Self { + self.inner.device_event = device_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_event: DisplayEventTypeEXT, +} +impl ::std::default::Default for DisplayEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + display_event: DisplayEventTypeEXT::default(), + } + } +} +unsafe impl TaggedStructure for DisplayEventInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_EVENT_INFO_EXT; +} +impl DisplayEventInfoEXT { + pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> { + DisplayEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayEventInfoEXTBuilder<'a> { + inner: DisplayEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> { + type Target = DisplayEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayEventInfoEXTBuilder<'a> { + #[inline] + pub fn display_event(mut self, display_event: DisplayEventTypeEXT) -> Self { + self.inner.display_event = display_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainCounterCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub surface_counters: SurfaceCounterFlagsEXT, +} +impl ::std::default::Default for SwapchainCounterCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + surface_counters: SurfaceCounterFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainCounterCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT; +} +impl SwapchainCounterCreateInfoEXT { + pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> { + SwapchainCounterCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainCounterCreateInfoEXTBuilder<'a> { + inner: SwapchainCounterCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> { + type Target = SwapchainCounterCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> { + #[inline] + pub fn surface_counters(mut self, surface_counters: SurfaceCounterFlagsEXT) -> Self { + self.inner.surface_counters = surface_counters; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainCounterCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGroupProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub physical_device_count: u32, + pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], + pub subset_allocation: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGroupProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + physical_device_count: u32::default(), + physical_devices: unsafe { ::std::mem::zeroed() }, + subset_allocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceGroupProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES; +} +impl PhysicalDeviceGroupProperties { + pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> { + PhysicalDeviceGroupPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGroupPropertiesBuilder<'a> { + inner: PhysicalDeviceGroupProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> { + type Target = PhysicalDeviceGroupProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { + #[inline] + pub fn physical_device_count(mut self, physical_device_count: u32) -> Self { + self.inner.physical_device_count = physical_device_count; + self + } + #[inline] + pub fn physical_devices( + mut self, + physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], + ) -> Self { + self.inner.physical_devices = physical_devices; + self + } + #[inline] + pub fn subset_allocation(mut self, subset_allocation: bool) -> Self { + self.inner.subset_allocation = subset_allocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGroupProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryAllocateFlagsInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MemoryAllocateFlags, + pub device_mask: u32, +} +impl ::std::default::Default for MemoryAllocateFlagsInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: MemoryAllocateFlags::default(), + device_mask: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryAllocateFlagsInfo { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ALLOCATE_FLAGS_INFO; +} +impl MemoryAllocateFlagsInfo { + pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> { + MemoryAllocateFlagsInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryAllocateFlagsInfoBuilder<'a> { + inner: MemoryAllocateFlagsInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {} +impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> { + type Target = MemoryAllocateFlagsInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryAllocateFlagsInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: MemoryAllocateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryAllocateFlagsInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindBufferMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, +} +impl ::std::default::Default for BindBufferMemoryInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BindBufferMemoryInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_BUFFER_MEMORY_INFO; +} +impl BindBufferMemoryInfo { + pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> { + BindBufferMemoryInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindBufferMemoryInfoBuilder<'a> { + inner: BindBufferMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBindBufferMemoryInfo {} +impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> { + type Target = BindBufferMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindBufferMemoryInfoBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindBufferMemoryInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindBufferMemoryDeviceGroupInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_index_count: u32, + pub p_device_indices: *const u32, +} +impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_index_count: u32::default(), + p_device_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BindBufferMemoryDeviceGroupInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; +} +impl BindBufferMemoryDeviceGroupInfo { + pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> { + BindBufferMemoryDeviceGroupInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> { + inner: BindBufferMemoryDeviceGroupInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {} +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {} +impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> { + type Target = BindBufferMemoryDeviceGroupInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> { + #[inline] + pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { + self.inner.device_index_count = device_indices.len() as _; + self.inner.p_device_indices = device_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindBufferMemoryDeviceGroupInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindImageMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, +} +impl ::std::default::Default for BindImageMemoryInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BindImageMemoryInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_INFO; +} +impl BindImageMemoryInfo { + pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> { + BindImageMemoryInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindImageMemoryInfoBuilder<'a> { + inner: BindImageMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBindImageMemoryInfo {} +impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> { + type Target = BindImageMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindImageMemoryInfoBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindImageMemoryInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindImageMemoryDeviceGroupInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_index_count: u32, + pub p_device_indices: *const u32, + pub split_instance_bind_region_count: u32, + pub p_split_instance_bind_regions: *const Rect2D, +} +impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_index_count: u32::default(), + p_device_indices: ::std::ptr::null(), + split_instance_bind_region_count: u32::default(), + p_split_instance_bind_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BindImageMemoryDeviceGroupInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; +} +impl BindImageMemoryDeviceGroupInfo { + pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> { + BindImageMemoryDeviceGroupInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> { + inner: BindImageMemoryDeviceGroupInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {} +impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> { + type Target = BindImageMemoryDeviceGroupInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> { + #[inline] + pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { + self.inner.device_index_count = device_indices.len() as _; + self.inner.p_device_indices = device_indices.as_ptr(); + self + } + #[inline] + pub fn split_instance_bind_regions( + mut self, + split_instance_bind_regions: &'a [Rect2D], + ) -> Self { + self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as _; + self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindImageMemoryDeviceGroupInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupRenderPassBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_mask: u32, + pub device_render_area_count: u32, + pub p_device_render_areas: *const Rect2D, +} +impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_mask: u32::default(), + device_render_area_count: u32::default(), + p_device_render_areas: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupRenderPassBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; +} +impl DeviceGroupRenderPassBeginInfo { + pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> { + DeviceGroupRenderPassBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> { + inner: DeviceGroupRenderPassBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {} +unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> { + type Target = DeviceGroupRenderPassBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> { + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[inline] + pub fn device_render_areas(mut self, device_render_areas: &'a [Rect2D]) -> Self { + self.inner.device_render_area_count = device_render_areas.len() as _; + self.inner.p_device_render_areas = device_render_areas.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupRenderPassBeginInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupCommandBufferBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_mask: u32, +} +impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_mask: u32::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupCommandBufferBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; +} +impl DeviceGroupCommandBufferBeginInfo { + pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> { + DeviceGroupCommandBufferBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> { + inner: DeviceGroupCommandBufferBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {} +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> { + type Target = DeviceGroupCommandBufferBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> { + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupCommandBufferBeginInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: u32, + pub p_wait_semaphore_device_indices: *const u32, + pub command_buffer_count: u32, + pub p_command_buffer_device_masks: *const u32, + pub signal_semaphore_count: u32, + pub p_signal_semaphore_device_indices: *const u32, +} +impl ::std::default::Default for DeviceGroupSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_count: u32::default(), + p_wait_semaphore_device_indices: ::std::ptr::null(), + command_buffer_count: u32::default(), + p_command_buffer_device_masks: ::std::ptr::null(), + signal_semaphore_count: u32::default(), + p_signal_semaphore_device_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_SUBMIT_INFO; +} +impl DeviceGroupSubmitInfo { + pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> { + DeviceGroupSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupSubmitInfoBuilder<'a> { + inner: DeviceGroupSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> { + type Target = DeviceGroupSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupSubmitInfoBuilder<'a> { + #[inline] + pub fn wait_semaphore_device_indices( + mut self, + wait_semaphore_device_indices: &'a [u32], + ) -> Self { + self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as _; + self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr(); + self + } + #[inline] + pub fn command_buffer_device_masks(mut self, command_buffer_device_masks: &'a [u32]) -> Self { + self.inner.command_buffer_count = command_buffer_device_masks.len() as _; + self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr(); + self + } + #[inline] + pub fn signal_semaphore_device_indices( + mut self, + signal_semaphore_device_indices: &'a [u32], + ) -> Self { + self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as _; + self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupBindSparseInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub resource_device_index: u32, + pub memory_device_index: u32, +} +impl ::std::default::Default for DeviceGroupBindSparseInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + resource_device_index: u32::default(), + memory_device_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupBindSparseInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_BIND_SPARSE_INFO; +} +impl DeviceGroupBindSparseInfo { + pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> { + DeviceGroupBindSparseInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupBindSparseInfoBuilder<'a> { + inner: DeviceGroupBindSparseInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {} +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> { + type Target = DeviceGroupBindSparseInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupBindSparseInfoBuilder<'a> { + #[inline] + pub fn resource_device_index(mut self, resource_device_index: u32) -> Self { + self.inner.resource_device_index = resource_device_index; + self + } + #[inline] + pub fn memory_device_index(mut self, memory_device_index: u32) -> Self { + self.inner.memory_device_index = memory_device_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupBindSparseInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupPresentCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE], + pub modes: DeviceGroupPresentModeFlagsKHR, +} +impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mask: unsafe { ::std::mem::zeroed() }, + modes: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupPresentCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR; +} +impl DeviceGroupPresentCapabilitiesKHR { + pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + DeviceGroupPresentCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + inner: DeviceGroupPresentCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + type Target = DeviceGroupPresentCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn present_mask(mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE]) -> Self { + self.inner.present_mask = present_mask; + self + } + #[inline] + pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self { + self.inner.modes = modes; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageSwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, +} +impl ::std::default::Default for ImageSwapchainCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + } + } +} +unsafe impl TaggedStructure for ImageSwapchainCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR; +} +impl ImageSwapchainCreateInfoKHR { + pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> { + ImageSwapchainCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSwapchainCreateInfoKHRBuilder<'a> { + inner: ImageSwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {} +impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> { + type Target = ImageSwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.inner.swapchain = swapchain; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSwapchainCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindImageMemorySwapchainInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub image_index: u32, +} +impl ::std::default::Default for BindImageMemorySwapchainInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + image_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for BindImageMemorySwapchainInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR; +} +impl BindImageMemorySwapchainInfoKHR { + pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> { + BindImageMemorySwapchainInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> { + inner: BindImageMemorySwapchainInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {} +impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> { + type Target = BindImageMemorySwapchainInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.inner.swapchain = swapchain; + self + } + #[inline] + pub fn image_index(mut self, image_index: u32) -> Self { + self.inner.image_index = image_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindImageMemorySwapchainInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AcquireNextImageInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub timeout: u64, + pub semaphore: Semaphore, + pub fence: Fence, + pub device_mask: u32, +} +impl ::std::default::Default for AcquireNextImageInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + timeout: u64::default(), + semaphore: Semaphore::default(), + fence: Fence::default(), + device_mask: u32::default(), + } + } +} +unsafe impl TaggedStructure for AcquireNextImageInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR; +} +impl AcquireNextImageInfoKHR { + pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> { + AcquireNextImageInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AcquireNextImageInfoKHRBuilder<'a> { + inner: AcquireNextImageInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> { + type Target = AcquireNextImageInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AcquireNextImageInfoKHRBuilder<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.inner.swapchain = swapchain; + self + } + #[inline] + pub fn timeout(mut self, timeout: u64) -> Self { + self.inner.timeout = timeout; + self + } + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AcquireNextImageInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupPresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_device_masks: *const u32, + pub mode: DeviceGroupPresentModeFlagsKHR, +} +impl ::std::default::Default for DeviceGroupPresentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_device_masks: ::std::ptr::null(), + mode: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupPresentInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_PRESENT_INFO_KHR; +} +impl DeviceGroupPresentInfoKHR { + pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> { + DeviceGroupPresentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupPresentInfoKHRBuilder<'a> { + inner: DeviceGroupPresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {} +impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> { + type Target = DeviceGroupPresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> { + #[inline] + pub fn device_masks(mut self, device_masks: &'a [u32]) -> Self { + self.inner.swapchain_count = device_masks.len() as _; + self.inner.p_device_masks = device_masks.as_ptr(); + self + } + #[inline] + pub fn mode(mut self, mode: DeviceGroupPresentModeFlagsKHR) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupPresentInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupDeviceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub physical_device_count: u32, + pub p_physical_devices: *const PhysicalDevice, +} +impl ::std::default::Default for DeviceGroupDeviceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + physical_device_count: u32::default(), + p_physical_devices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupDeviceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO; +} +impl DeviceGroupDeviceCreateInfo { + pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> { + DeviceGroupDeviceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupDeviceCreateInfoBuilder<'a> { + inner: DeviceGroupDeviceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> { + type Target = DeviceGroupDeviceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> { + #[inline] + pub fn physical_devices(mut self, physical_devices: &'a [PhysicalDevice]) -> Self { + self.inner.physical_device_count = physical_devices.len() as _; + self.inner.p_physical_devices = physical_devices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupDeviceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupSwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub modes: DeviceGroupPresentModeFlagsKHR, +} +impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + modes: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupSwapchainCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR; +} +impl DeviceGroupSwapchainCreateInfoKHR { + pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + DeviceGroupSwapchainCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + inner: DeviceGroupSwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {} +impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + type Target = DeviceGroupSwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + #[inline] + pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self { + self.inner.modes = modes; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DescriptorUpdateTemplateEntry { + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, + pub descriptor_type: DescriptorType, + pub offset: usize, + pub stride: usize, +} +impl DescriptorUpdateTemplateEntry { + pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> { + DescriptorUpdateTemplateEntryBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorUpdateTemplateEntryBuilder<'a> { + inner: DescriptorUpdateTemplateEntry, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> { + type Target = DescriptorUpdateTemplateEntry; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> { + #[inline] + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.inner.dst_binding = dst_binding; + self + } + #[inline] + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.inner.dst_array_element = dst_array_element; + self + } + #[inline] + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.inner.descriptor_count = descriptor_count; + self + } + #[inline] + pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { + self.inner.descriptor_type = descriptor_type; + self + } + #[inline] + pub fn offset(mut self, offset: usize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn stride(mut self, stride: usize) -> Self { + self.inner.stride = stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorUpdateTemplateEntry { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorUpdateTemplateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorUpdateTemplateCreateFlags, + pub descriptor_update_entry_count: u32, + pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry, + pub template_type: DescriptorUpdateTemplateType, + pub descriptor_set_layout: DescriptorSetLayout, + pub pipeline_bind_point: PipelineBindPoint, + pub pipeline_layout: PipelineLayout, + pub set: u32, +} +impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DescriptorUpdateTemplateCreateFlags::default(), + descriptor_update_entry_count: u32::default(), + p_descriptor_update_entries: ::std::ptr::null(), + template_type: DescriptorUpdateTemplateType::default(), + descriptor_set_layout: DescriptorSetLayout::default(), + pipeline_bind_point: PipelineBindPoint::default(), + pipeline_layout: PipelineLayout::default(), + set: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorUpdateTemplateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; +} +impl DescriptorUpdateTemplateCreateInfo { + pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + DescriptorUpdateTemplateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> { + inner: DescriptorUpdateTemplateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> { + type Target = DescriptorUpdateTemplateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DescriptorUpdateTemplateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn descriptor_update_entries( + mut self, + descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry], + ) -> Self { + self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as _; + self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr(); + self + } + #[inline] + pub fn template_type(mut self, template_type: DescriptorUpdateTemplateType) -> Self { + self.inner.template_type = template_type; + self + } + #[inline] + pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { + self.inner.descriptor_set_layout = descriptor_set_layout; + self + } + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn pipeline_layout(mut self, pipeline_layout: PipelineLayout) -> Self { + self.inner.pipeline_layout = pipeline_layout; + self + } + #[inline] + pub fn set(mut self, set: u32) -> Self { + self.inner.set = set; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorUpdateTemplateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct XYColorEXT { + pub x: f32, + pub y: f32, +} +impl XYColorEXT { + pub fn builder<'a>() -> XYColorEXTBuilder<'a> { + XYColorEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct XYColorEXTBuilder<'a> { + inner: XYColorEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> { + type Target = XYColorEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> XYColorEXTBuilder<'a> { + #[inline] + pub fn x(mut self, x: f32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: f32) -> Self { + self.inner.y = y; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> XYColorEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentIdFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_id: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_id: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePresentIdFeaturesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; +} +impl PhysicalDevicePresentIdFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + PhysicalDevicePresentIdFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePresentIdFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePresentIdFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + #[inline] + pub fn present_id(mut self, present_id: bool) -> Self { + self.inner.present_id = present_id.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePresentIdFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentIdKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_present_ids: *const u64, +} +impl ::std::default::Default for PresentIdKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_present_ids: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PresentIdKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_ID_KHR; +} +impl PresentIdKHR { + pub fn builder<'a>() -> PresentIdKHRBuilder<'a> { + PresentIdKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentIdKHRBuilder<'a> { + inner: PresentIdKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {} +impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> { + type Target = PresentIdKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentIdKHRBuilder<'a> { + #[inline] + pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self { + self.inner.swapchain_count = present_ids.len() as _; + self.inner.p_present_ids = present_ids.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentIdKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentWaitFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_wait: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_wait: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePresentWaitFeaturesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; +} +impl PhysicalDevicePresentWaitFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + PhysicalDevicePresentWaitFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePresentWaitFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePresentWaitFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + #[inline] + pub fn present_wait(mut self, present_wait: bool) -> Self { + self.inner.present_wait = present_wait.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePresentWaitFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct HdrMetadataEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_primary_red: XYColorEXT, + pub display_primary_green: XYColorEXT, + pub display_primary_blue: XYColorEXT, + pub white_point: XYColorEXT, + pub max_luminance: f32, + pub min_luminance: f32, + pub max_content_light_level: f32, + pub max_frame_average_light_level: f32, +} +impl ::std::default::Default for HdrMetadataEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + display_primary_red: XYColorEXT::default(), + display_primary_green: XYColorEXT::default(), + display_primary_blue: XYColorEXT::default(), + white_point: XYColorEXT::default(), + max_luminance: f32::default(), + min_luminance: f32::default(), + max_content_light_level: f32::default(), + max_frame_average_light_level: f32::default(), + } + } +} +unsafe impl TaggedStructure for HdrMetadataEXT { + const STRUCTURE_TYPE: StructureType = StructureType::HDR_METADATA_EXT; +} +impl HdrMetadataEXT { + pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> { + HdrMetadataEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct HdrMetadataEXTBuilder<'a> { + inner: HdrMetadataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> { + type Target = HdrMetadataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> HdrMetadataEXTBuilder<'a> { + #[inline] + pub fn display_primary_red(mut self, display_primary_red: XYColorEXT) -> Self { + self.inner.display_primary_red = display_primary_red; + self + } + #[inline] + pub fn display_primary_green(mut self, display_primary_green: XYColorEXT) -> Self { + self.inner.display_primary_green = display_primary_green; + self + } + #[inline] + pub fn display_primary_blue(mut self, display_primary_blue: XYColorEXT) -> Self { + self.inner.display_primary_blue = display_primary_blue; + self + } + #[inline] + pub fn white_point(mut self, white_point: XYColorEXT) -> Self { + self.inner.white_point = white_point; + self + } + #[inline] + pub fn max_luminance(mut self, max_luminance: f32) -> Self { + self.inner.max_luminance = max_luminance; + self + } + #[inline] + pub fn min_luminance(mut self, min_luminance: f32) -> Self { + self.inner.min_luminance = min_luminance; + self + } + #[inline] + pub fn max_content_light_level(mut self, max_content_light_level: f32) -> Self { + self.inner.max_content_light_level = max_content_light_level; + self + } + #[inline] + pub fn max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self { + self.inner.max_frame_average_light_level = max_frame_average_light_level; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> HdrMetadataEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayNativeHdrSurfaceCapabilitiesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub local_dimming_support: Bool32, +} +impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + local_dimming_support: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DisplayNativeHdrSurfaceCapabilitiesAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD; +} +impl DisplayNativeHdrSurfaceCapabilitiesAMD { + pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + DisplayNativeHdrSurfaceCapabilitiesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + inner: DisplayNativeHdrSurfaceCapabilitiesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD {} +impl<'a> ::std::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + type Target = DisplayNativeHdrSurfaceCapabilitiesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + #[inline] + pub fn local_dimming_support(mut self, local_dimming_support: bool) -> Self { + self.inner.local_dimming_support = local_dimming_support.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainDisplayNativeHdrCreateInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub local_dimming_enable: Bool32, +} +impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + local_dimming_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainDisplayNativeHdrCreateInfoAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD; +} +impl SwapchainDisplayNativeHdrCreateInfoAMD { + pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + SwapchainDisplayNativeHdrCreateInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + inner: SwapchainDisplayNativeHdrCreateInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD {} +impl<'a> ::std::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + type Target = SwapchainDisplayNativeHdrCreateInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + #[inline] + pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self { + self.inner.local_dimming_enable = local_dimming_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct RefreshCycleDurationGOOGLE { + pub refresh_duration: u64, +} +impl RefreshCycleDurationGOOGLE { + pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> { + RefreshCycleDurationGOOGLEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RefreshCycleDurationGOOGLEBuilder<'a> { + inner: RefreshCycleDurationGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> { + type Target = RefreshCycleDurationGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> { + #[inline] + pub fn refresh_duration(mut self, refresh_duration: u64) -> Self { + self.inner.refresh_duration = refresh_duration; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RefreshCycleDurationGOOGLE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PastPresentationTimingGOOGLE { + pub present_id: u32, + pub desired_present_time: u64, + pub actual_present_time: u64, + pub earliest_present_time: u64, + pub present_margin: u64, +} +impl PastPresentationTimingGOOGLE { + pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> { + PastPresentationTimingGOOGLEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PastPresentationTimingGOOGLEBuilder<'a> { + inner: PastPresentationTimingGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> { + type Target = PastPresentationTimingGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PastPresentationTimingGOOGLEBuilder<'a> { + #[inline] + pub fn present_id(mut self, present_id: u32) -> Self { + self.inner.present_id = present_id; + self + } + #[inline] + pub fn desired_present_time(mut self, desired_present_time: u64) -> Self { + self.inner.desired_present_time = desired_present_time; + self + } + #[inline] + pub fn actual_present_time(mut self, actual_present_time: u64) -> Self { + self.inner.actual_present_time = actual_present_time; + self + } + #[inline] + pub fn earliest_present_time(mut self, earliest_present_time: u64) -> Self { + self.inner.earliest_present_time = earliest_present_time; + self + } + #[inline] + pub fn present_margin(mut self, present_margin: u64) -> Self { + self.inner.present_margin = present_margin; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PastPresentationTimingGOOGLE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentTimesInfoGOOGLE { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_times: *const PresentTimeGOOGLE, +} +impl ::std::default::Default for PresentTimesInfoGOOGLE { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_times: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PresentTimesInfoGOOGLE { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_TIMES_INFO_GOOGLE; +} +impl PresentTimesInfoGOOGLE { + pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> { + PresentTimesInfoGOOGLEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentTimesInfoGOOGLEBuilder<'a> { + inner: PresentTimesInfoGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {} +impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> { + type Target = PresentTimesInfoGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentTimesInfoGOOGLEBuilder<'a> { + #[inline] + pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> Self { + self.inner.swapchain_count = times.len() as _; + self.inner.p_times = times.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentTimesInfoGOOGLE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PresentTimeGOOGLE { + pub present_id: u32, + pub desired_present_time: u64, +} +impl PresentTimeGOOGLE { + pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> { + PresentTimeGOOGLEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentTimeGOOGLEBuilder<'a> { + inner: PresentTimeGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> { + type Target = PresentTimeGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentTimeGOOGLEBuilder<'a> { + #[inline] + pub fn present_id(mut self, present_id: u32) -> Self { + self.inner.present_id = present_id; + self + } + #[inline] + pub fn desired_present_time(mut self, desired_present_time: u64) -> Self { + self.inner.desired_present_time = desired_present_time; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentTimeGOOGLE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct IOSSurfaceCreateInfoMVK { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: IOSSurfaceCreateFlagsMVK, + pub p_view: *const c_void, +} +impl ::std::default::Default for IOSSurfaceCreateInfoMVK { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: IOSSurfaceCreateFlagsMVK::default(), + p_view: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for IOSSurfaceCreateInfoMVK { + const STRUCTURE_TYPE: StructureType = StructureType::IOS_SURFACE_CREATE_INFO_MVK; +} +impl IOSSurfaceCreateInfoMVK { + pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> { + IOSSurfaceCreateInfoMVKBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct IOSSurfaceCreateInfoMVKBuilder<'a> { + inner: IOSSurfaceCreateInfoMVK, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> { + type Target = IOSSurfaceCreateInfoMVK; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn view(mut self, view: *const c_void) -> Self { + self.inner.p_view = view; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> IOSSurfaceCreateInfoMVK { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MacOSSurfaceCreateInfoMVK { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MacOSSurfaceCreateFlagsMVK, + pub p_view: *const c_void, +} +impl ::std::default::Default for MacOSSurfaceCreateInfoMVK { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: MacOSSurfaceCreateFlagsMVK::default(), + p_view: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for MacOSSurfaceCreateInfoMVK { + const STRUCTURE_TYPE: StructureType = StructureType::MACOS_SURFACE_CREATE_INFO_MVK; +} +impl MacOSSurfaceCreateInfoMVK { + pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + MacOSSurfaceCreateInfoMVKBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> { + inner: MacOSSurfaceCreateInfoMVK, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> { + type Target = MacOSSurfaceCreateInfoMVK; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: MacOSSurfaceCreateFlagsMVK) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn view(mut self, view: *const c_void) -> Self { + self.inner.p_view = view; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MacOSSurfaceCreateInfoMVK { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MetalSurfaceCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MetalSurfaceCreateFlagsEXT, + pub p_layer: *const CAMetalLayer, +} +impl ::std::default::Default for MetalSurfaceCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: MetalSurfaceCreateFlagsEXT::default(), + p_layer: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for MetalSurfaceCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::METAL_SURFACE_CREATE_INFO_EXT; +} +impl MetalSurfaceCreateInfoEXT { + pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> { + MetalSurfaceCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MetalSurfaceCreateInfoEXTBuilder<'a> { + inner: MetalSurfaceCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> { + type Target = MetalSurfaceCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: MetalSurfaceCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn layer(mut self, layer: *const CAMetalLayer) -> Self { + self.inner.p_layer = layer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MetalSurfaceCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ViewportWScalingNV { + pub xcoeff: f32, + pub ycoeff: f32, +} +impl ViewportWScalingNV { + pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> { + ViewportWScalingNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ViewportWScalingNVBuilder<'a> { + inner: ViewportWScalingNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> { + type Target = ViewportWScalingNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ViewportWScalingNVBuilder<'a> { + #[inline] + pub fn xcoeff(mut self, xcoeff: f32) -> Self { + self.inner.xcoeff = xcoeff; + self + } + #[inline] + pub fn ycoeff(mut self, ycoeff: f32) -> Self { + self.inner.ycoeff = ycoeff; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ViewportWScalingNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportWScalingStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub viewport_w_scaling_enable: Bool32, + pub viewport_count: u32, + pub p_viewport_w_scalings: *const ViewportWScalingNV, +} +impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + viewport_w_scaling_enable: Bool32::default(), + viewport_count: u32::default(), + p_viewport_w_scalings: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportWScalingStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; +} +impl PipelineViewportWScalingStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + PipelineViewportWScalingStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportWScalingStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportWScalingStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportWScalingStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self { + self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into(); + self + } + #[inline] + pub fn viewport_w_scalings(mut self, viewport_w_scalings: &'a [ViewportWScalingNV]) -> Self { + self.inner.viewport_count = viewport_w_scalings.len() as _; + self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ViewportSwizzleNV { + pub x: ViewportCoordinateSwizzleNV, + pub y: ViewportCoordinateSwizzleNV, + pub z: ViewportCoordinateSwizzleNV, + pub w: ViewportCoordinateSwizzleNV, +} +impl ViewportSwizzleNV { + pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> { + ViewportSwizzleNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ViewportSwizzleNVBuilder<'a> { + inner: ViewportSwizzleNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> { + type Target = ViewportSwizzleNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ViewportSwizzleNVBuilder<'a> { + #[inline] + pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> Self { + self.inner.y = y; + self + } + #[inline] + pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> Self { + self.inner.z = z; + self + } + #[inline] + pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> Self { + self.inner.w = w; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ViewportSwizzleNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportSwizzleStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineViewportSwizzleStateCreateFlagsNV, + pub viewport_count: u32, + pub p_viewport_swizzles: *const ViewportSwizzleNV, +} +impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineViewportSwizzleStateCreateFlagsNV::default(), + viewport_count: u32::default(), + p_viewport_swizzles: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportSwizzleStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; +} +impl PipelineViewportSwizzleStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + PipelineViewportSwizzleStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportSwizzleStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportSwizzleStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn viewport_swizzles(mut self, viewport_swizzles: &'a [ViewportSwizzleNV]) -> Self { + self.inner.viewport_count = viewport_swizzles.len() as _; + self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_discard_rectangles: u32, +} +impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_discard_rectangles: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDiscardRectanglePropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; +} +impl PhysicalDeviceDiscardRectanglePropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + PhysicalDeviceDiscardRectanglePropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDiscardRectanglePropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDiscardRectanglePropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + #[inline] + pub fn max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self { + self.inner.max_discard_rectangles = max_discard_rectangles; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineDiscardRectangleStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDiscardRectangleStateCreateFlagsEXT, + pub discard_rectangle_mode: DiscardRectangleModeEXT, + pub discard_rectangle_count: u32, + pub p_discard_rectangles: *const Rect2D, +} +impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(), + discard_rectangle_mode: DiscardRectangleModeEXT::default(), + discard_rectangle_count: u32::default(), + p_discard_rectangles: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineDiscardRectangleStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; +} +impl PipelineDiscardRectangleStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + PipelineDiscardRectangleStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + inner: PipelineDiscardRectangleStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {} +impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + type Target = PipelineDiscardRectangleStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn discard_rectangle_mode( + mut self, + discard_rectangle_mode: DiscardRectangleModeEXT, + ) -> Self { + self.inner.discard_rectangle_mode = discard_rectangle_mode; + self + } + #[inline] + pub fn discard_rectangles(mut self, discard_rectangles: &'a [Rect2D]) -> Self { + self.inner.discard_rectangle_count = discard_rectangles.len() as _; + self.inner.p_discard_rectangles = discard_rectangles.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub per_view_position_all_components: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + per_view_position_all_components: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; +} +impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + #[inline] + pub fn per_view_position_all_components( + mut self, + per_view_position_all_components: bool, + ) -> Self { + self.inner.per_view_position_all_components = per_view_position_all_components.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct InputAttachmentAspectReference { + pub subpass: u32, + pub input_attachment_index: u32, + pub aspect_mask: ImageAspectFlags, +} +impl InputAttachmentAspectReference { + pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> { + InputAttachmentAspectReferenceBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct InputAttachmentAspectReferenceBuilder<'a> { + inner: InputAttachmentAspectReference, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> { + type Target = InputAttachmentAspectReference; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> InputAttachmentAspectReferenceBuilder<'a> { + #[inline] + pub fn subpass(mut self, subpass: u32) -> Self { + self.inner.subpass = subpass; + self + } + #[inline] + pub fn input_attachment_index(mut self, input_attachment_index: u32) -> Self { + self.inner.input_attachment_index = input_attachment_index; + self + } + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> InputAttachmentAspectReference { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassInputAttachmentAspectCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub aspect_reference_count: u32, + pub p_aspect_references: *const InputAttachmentAspectReference, +} +impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + aspect_reference_count: u32::default(), + p_aspect_references: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassInputAttachmentAspectCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; +} +impl RenderPassInputAttachmentAspectCreateInfo { + pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + RenderPassInputAttachmentAspectCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + inner: RenderPassInputAttachmentAspectCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {} +impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + type Target = RenderPassInputAttachmentAspectCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + #[inline] + pub fn aspect_references( + mut self, + aspect_references: &'a [InputAttachmentAspectReference], + ) -> Self { + self.inner.aspect_reference_count = aspect_references.len() as _; + self.inner.p_aspect_references = aspect_references.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSurfaceInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub surface: SurfaceKHR, +} +impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + surface: SurfaceKHR::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSurfaceInfo2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; +} +impl PhysicalDeviceSurfaceInfo2KHR { + pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + PhysicalDeviceSurfaceInfo2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + inner: PhysicalDeviceSurfaceInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + type Target = PhysicalDeviceSurfaceInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + #[inline] + pub fn surface(mut self, surface: SurfaceKHR) -> Self { + self.inner.surface = surface; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilities2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub surface_capabilities: SurfaceCapabilitiesKHR, +} +impl ::std::default::Default for SurfaceCapabilities2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + surface_capabilities: SurfaceCapabilitiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceCapabilities2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_2_KHR; +} +impl SurfaceCapabilities2KHR { + pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> { + SurfaceCapabilities2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilities2KHRBuilder<'a> { + inner: SurfaceCapabilities2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSurfaceCapabilities2KHR {} +impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> { + type Target = SurfaceCapabilities2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilities2KHRBuilder<'a> { + #[inline] + pub fn surface_capabilities(mut self, surface_capabilities: SurfaceCapabilitiesKHR) -> Self { + self.inner.surface_capabilities = surface_capabilities; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilities2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceFormat2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub surface_format: SurfaceFormatKHR, +} +impl ::std::default::Default for SurfaceFormat2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + surface_format: SurfaceFormatKHR::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceFormat2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FORMAT_2_KHR; +} +impl SurfaceFormat2KHR { + pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> { + SurfaceFormat2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceFormat2KHRBuilder<'a> { + inner: SurfaceFormat2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSurfaceFormat2KHR {} +impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> { + type Target = SurfaceFormat2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceFormat2KHRBuilder<'a> { + #[inline] + pub fn surface_format(mut self, surface_format: SurfaceFormatKHR) -> Self { + self.inner.surface_format = surface_format; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceFormat2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayProperties2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub display_properties: DisplayPropertiesKHR, +} +impl ::std::default::Default for DisplayProperties2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + display_properties: DisplayPropertiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayProperties2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PROPERTIES_2_KHR; +} +impl DisplayProperties2KHR { + pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> { + DisplayProperties2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayProperties2KHRBuilder<'a> { + inner: DisplayProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> { + type Target = DisplayProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayProperties2KHRBuilder<'a> { + #[inline] + pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR) -> Self { + self.inner.display_properties = display_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayProperties2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPlaneProperties2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub display_plane_properties: DisplayPlanePropertiesKHR, +} +impl ::std::default::Default for DisplayPlaneProperties2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + display_plane_properties: DisplayPlanePropertiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPlaneProperties2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR; +} +impl DisplayPlaneProperties2KHR { + pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> { + DisplayPlaneProperties2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlaneProperties2KHRBuilder<'a> { + inner: DisplayPlaneProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> { + type Target = DisplayPlaneProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { + #[inline] + pub fn display_plane_properties( + mut self, + display_plane_properties: DisplayPlanePropertiesKHR, + ) -> Self { + self.inner.display_plane_properties = display_plane_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlaneProperties2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayModeProperties2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub display_mode_properties: DisplayModePropertiesKHR, +} +impl ::std::default::Default for DisplayModeProperties2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + display_mode_properties: DisplayModePropertiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayModeProperties2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_PROPERTIES_2_KHR; +} +impl DisplayModeProperties2KHR { + pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> { + DisplayModeProperties2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayModeProperties2KHRBuilder<'a> { + inner: DisplayModeProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> { + type Target = DisplayModeProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayModeProperties2KHRBuilder<'a> { + #[inline] + pub fn display_mode_properties( + mut self, + display_mode_properties: DisplayModePropertiesKHR, + ) -> Self { + self.inner.display_mode_properties = display_mode_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayModeProperties2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPlaneInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mode: DisplayModeKHR, + pub plane_index: u32, +} +impl ::std::default::Default for DisplayPlaneInfo2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mode: DisplayModeKHR::default(), + plane_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPlaneInfo2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_INFO_2_KHR; +} +impl DisplayPlaneInfo2KHR { + pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> { + DisplayPlaneInfo2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlaneInfo2KHRBuilder<'a> { + inner: DisplayPlaneInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> { + type Target = DisplayPlaneInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { + #[inline] + pub fn mode(mut self, mode: DisplayModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[inline] + pub fn plane_index(mut self, plane_index: u32) -> Self { + self.inner.plane_index = plane_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlaneInfo2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPlaneCapabilities2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub capabilities: DisplayPlaneCapabilitiesKHR, +} +impl ::std::default::Default for DisplayPlaneCapabilities2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + capabilities: DisplayPlaneCapabilitiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPlaneCapabilities2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR; +} +impl DisplayPlaneCapabilities2KHR { + pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> { + DisplayPlaneCapabilities2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlaneCapabilities2KHRBuilder<'a> { + inner: DisplayPlaneCapabilities2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> { + type Target = DisplayPlaneCapabilities2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { + #[inline] + pub fn capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self { + self.inner.capabilities = capabilities; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlaneCapabilities2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SharedPresentSurfaceCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shared_present_supported_usage_flags: ImageUsageFlags, +} +impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shared_present_supported_usage_flags: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for SharedPresentSurfaceCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; +} +impl SharedPresentSurfaceCapabilitiesKHR { + pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + SharedPresentSurfaceCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + inner: SharedPresentSurfaceCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + type Target = SharedPresentSurfaceCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn shared_present_supported_usage_flags( + mut self, + shared_present_supported_usage_flags: ImageUsageFlags, + ) -> Self { + self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevice16BitStorageFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub storage_buffer16_bit_access: Bool32, + pub uniform_and_storage_buffer16_bit_access: Bool32, + pub storage_push_constant16: Bool32, + pub storage_input_output16: Bool32, +} +impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + storage_buffer16_bit_access: Bool32::default(), + uniform_and_storage_buffer16_bit_access: Bool32::default(), + storage_push_constant16: Bool32::default(), + storage_input_output16: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevice16BitStorageFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; +} +impl PhysicalDevice16BitStorageFeatures { + pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + PhysicalDevice16BitStorageFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> { + inner: PhysicalDevice16BitStorageFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> { + type Target = PhysicalDevice16BitStorageFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + #[inline] + pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self { + self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); + self + } + #[inline] + pub fn uniform_and_storage_buffer16_bit_access( + mut self, + uniform_and_storage_buffer16_bit_access: bool, + ) -> Self { + self.inner.uniform_and_storage_buffer16_bit_access = + uniform_and_storage_buffer16_bit_access.into(); + self + } + #[inline] + pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self { + self.inner.storage_push_constant16 = storage_push_constant16.into(); + self + } + #[inline] + pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self { + self.inner.storage_input_output16 = storage_input_output16.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevice16BitStorageFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubgroupProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subgroup_size: u32, + pub supported_stages: ShaderStageFlags, + pub supported_operations: SubgroupFeatureFlags, + pub quad_operations_in_all_stages: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubgroupProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subgroup_size: u32::default(), + supported_stages: ShaderStageFlags::default(), + supported_operations: SubgroupFeatureFlags::default(), + quad_operations_in_all_stages: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubgroupProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; +} +impl PhysicalDeviceSubgroupProperties { + pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + PhysicalDeviceSubgroupPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> { + inner: PhysicalDeviceSubgroupProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> { + type Target = PhysicalDeviceSubgroupProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + #[inline] + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.inner.subgroup_size = subgroup_size; + self + } + #[inline] + pub fn supported_stages(mut self, supported_stages: ShaderStageFlags) -> Self { + self.inner.supported_stages = supported_stages; + self + } + #[inline] + pub fn supported_operations(mut self, supported_operations: SubgroupFeatureFlags) -> Self { + self.inner.supported_operations = supported_operations; + self + } + #[inline] + pub fn quad_operations_in_all_stages(mut self, quad_operations_in_all_stages: bool) -> Self { + self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubgroupProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_subgroup_extended_types: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_subgroup_extended_types: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; +} +impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + #[inline] + pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self { + self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for BufferMemoryRequirementsInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for BufferMemoryRequirementsInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2; +} +impl BufferMemoryRequirementsInfo2 { + pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> { + BufferMemoryRequirementsInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferMemoryRequirementsInfo2Builder<'a> { + inner: BufferMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> { + type Target = BufferMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferMemoryRequirementsInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceBufferMemoryRequirements { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_create_info: *const BufferCreateInfo, +} +impl ::std::default::Default for DeviceBufferMemoryRequirements { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_create_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceBufferMemoryRequirements { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS; +} +impl DeviceBufferMemoryRequirements { + pub fn builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a> { + DeviceBufferMemoryRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceBufferMemoryRequirementsBuilder<'a> { + inner: DeviceBufferMemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceBufferMemoryRequirementsBuilder<'a> { + type Target = DeviceBufferMemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceBufferMemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceBufferMemoryRequirementsBuilder<'a> { + #[inline] + pub fn create_info(mut self, create_info: &'a BufferCreateInfo) -> Self { + self.inner.p_create_info = create_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceBufferMemoryRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, +} +impl ::std::default::Default for ImageMemoryRequirementsInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + } + } +} +unsafe impl TaggedStructure for ImageMemoryRequirementsInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2; +} +impl ImageMemoryRequirementsInfo2 { + pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> { + ImageMemoryRequirementsInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageMemoryRequirementsInfo2Builder<'a> { + inner: ImageMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {} +impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> { + type Target = ImageMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageMemoryRequirementsInfo2Builder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageMemoryRequirementsInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageSparseMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, +} +impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + } + } +} +unsafe impl TaggedStructure for ImageSparseMemoryRequirementsInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; +} +impl ImageSparseMemoryRequirementsInfo2 { + pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> { + ImageSparseMemoryRequirementsInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> { + inner: ImageSparseMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> { + type Target = ImageSparseMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceImageMemoryRequirements { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_create_info: *const ImageCreateInfo, + pub plane_aspect: ImageAspectFlags, +} +impl ::std::default::Default for DeviceImageMemoryRequirements { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_create_info: ::std::ptr::null(), + plane_aspect: ImageAspectFlags::default(), + } + } +} +unsafe impl TaggedStructure for DeviceImageMemoryRequirements { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS; +} +impl DeviceImageMemoryRequirements { + pub fn builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a> { + DeviceImageMemoryRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceImageMemoryRequirementsBuilder<'a> { + inner: DeviceImageMemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceImageMemoryRequirementsBuilder<'a> { + type Target = DeviceImageMemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceImageMemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceImageMemoryRequirementsBuilder<'a> { + #[inline] + pub fn create_info(mut self, create_info: &'a ImageCreateInfo) -> Self { + self.inner.p_create_info = create_info; + self + } + #[inline] + pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { + self.inner.plane_aspect = plane_aspect; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceImageMemoryRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryRequirements2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_requirements: MemoryRequirements, +} +impl ::std::default::Default for MemoryRequirements2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_requirements: MemoryRequirements::default(), + } + } +} +unsafe impl TaggedStructure for MemoryRequirements2 { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_REQUIREMENTS_2; +} +impl MemoryRequirements2 { + pub fn builder<'a>() -> MemoryRequirements2Builder<'a> { + MemoryRequirements2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryRequirements2Builder<'a> { + inner: MemoryRequirements2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsMemoryRequirements2 {} +impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> { + type Target = MemoryRequirements2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryRequirements2Builder<'a> { + #[inline] + pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self { + self.inner.memory_requirements = memory_requirements; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryRequirements2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseImageMemoryRequirements2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_requirements: SparseImageMemoryRequirements, +} +impl ::std::default::Default for SparseImageMemoryRequirements2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_requirements: SparseImageMemoryRequirements::default(), + } + } +} +unsafe impl TaggedStructure for SparseImageMemoryRequirements2 { + const STRUCTURE_TYPE: StructureType = StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; +} +impl SparseImageMemoryRequirements2 { + pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> { + SparseImageMemoryRequirements2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageMemoryRequirements2Builder<'a> { + inner: SparseImageMemoryRequirements2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> { + type Target = SparseImageMemoryRequirements2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageMemoryRequirements2Builder<'a> { + #[inline] + pub fn memory_requirements( + mut self, + memory_requirements: SparseImageMemoryRequirements, + ) -> Self { + self.inner.memory_requirements = memory_requirements; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageMemoryRequirements2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePointClippingProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub point_clipping_behavior: PointClippingBehavior, +} +impl ::std::default::Default for PhysicalDevicePointClippingProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + point_clipping_behavior: PointClippingBehavior::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePointClippingProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; +} +impl PhysicalDevicePointClippingProperties { + pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> { + PhysicalDevicePointClippingPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> { + inner: PhysicalDevicePointClippingProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {} +impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> { + type Target = PhysicalDevicePointClippingProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> { + #[inline] + pub fn point_clipping_behavior( + mut self, + point_clipping_behavior: PointClippingBehavior, + ) -> Self { + self.inner.point_clipping_behavior = point_clipping_behavior; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePointClippingProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryDedicatedRequirements { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub prefers_dedicated_allocation: Bool32, + pub requires_dedicated_allocation: Bool32, +} +impl ::std::default::Default for MemoryDedicatedRequirements { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + prefers_dedicated_allocation: Bool32::default(), + requires_dedicated_allocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryDedicatedRequirements { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_DEDICATED_REQUIREMENTS; +} +impl MemoryDedicatedRequirements { + pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> { + MemoryDedicatedRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryDedicatedRequirementsBuilder<'a> { + inner: MemoryDedicatedRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {} +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {} +impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> { + type Target = MemoryDedicatedRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryDedicatedRequirementsBuilder<'a> { + #[inline] + pub fn prefers_dedicated_allocation(mut self, prefers_dedicated_allocation: bool) -> Self { + self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into(); + self + } + #[inline] + pub fn requires_dedicated_allocation(mut self, requires_dedicated_allocation: bool) -> Self { + self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryDedicatedRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryDedicatedAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub buffer: Buffer, +} +impl ::std::default::Default for MemoryDedicatedAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for MemoryDedicatedAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_DEDICATED_ALLOCATE_INFO; +} +impl MemoryDedicatedAllocateInfo { + pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> { + MemoryDedicatedAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryDedicatedAllocateInfoBuilder<'a> { + inner: MemoryDedicatedAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {} +impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> { + type Target = MemoryDedicatedAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryDedicatedAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewUsageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: ImageUsageFlags, +} +impl ::std::default::Default for ImageViewUsageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + usage: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewUsageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_USAGE_CREATE_INFO; +} +impl ImageViewUsageCreateInfo { + pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> { + ImageViewUsageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewUsageCreateInfoBuilder<'a> { + inner: ImageViewUsageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {} +impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> { + type Target = ImageViewUsageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewUsageCreateInfoBuilder<'a> { + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewUsageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineTessellationDomainOriginStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub domain_origin: TessellationDomainOrigin, +} +impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + domain_origin: TessellationDomainOrigin::default(), + } + } +} +unsafe impl TaggedStructure for PipelineTessellationDomainOriginStateCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; +} +impl PipelineTessellationDomainOriginStateCreateInfo { + pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + PipelineTessellationDomainOriginStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + inner: PipelineTessellationDomainOriginStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineTessellationStateCreateInfo + for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsPipelineTessellationStateCreateInfo + for PipelineTessellationDomainOriginStateCreateInfo +{ +} +impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + type Target = PipelineTessellationDomainOriginStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + #[inline] + pub fn domain_origin(mut self, domain_origin: TessellationDomainOrigin) -> Self { + self.inner.domain_origin = domain_origin; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerYcbcrConversionInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub conversion: SamplerYcbcrConversion, +} +impl ::std::default::Default for SamplerYcbcrConversionInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + conversion: SamplerYcbcrConversion::default(), + } + } +} +unsafe impl TaggedStructure for SamplerYcbcrConversionInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_YCBCR_CONVERSION_INFO; +} +impl SamplerYcbcrConversionInfo { + pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> { + SamplerYcbcrConversionInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerYcbcrConversionInfoBuilder<'a> { + inner: SamplerYcbcrConversionInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {} +unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> { + type Target = SamplerYcbcrConversionInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerYcbcrConversionInfoBuilder<'a> { + #[inline] + pub fn conversion(mut self, conversion: SamplerYcbcrConversion) -> Self { + self.inner.conversion = conversion; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerYcbcrConversionInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerYcbcrConversionCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ycbcr_model: SamplerYcbcrModelConversion, + pub ycbcr_range: SamplerYcbcrRange, + pub components: ComponentMapping, + pub x_chroma_offset: ChromaLocation, + pub y_chroma_offset: ChromaLocation, + pub chroma_filter: Filter, + pub force_explicit_reconstruction: Bool32, +} +impl ::std::default::Default for SamplerYcbcrConversionCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + ycbcr_model: SamplerYcbcrModelConversion::default(), + ycbcr_range: SamplerYcbcrRange::default(), + components: ComponentMapping::default(), + x_chroma_offset: ChromaLocation::default(), + y_chroma_offset: ChromaLocation::default(), + chroma_filter: Filter::default(), + force_explicit_reconstruction: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SamplerYcbcrConversionCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO; +} +impl SamplerYcbcrConversionCreateInfo { + pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + SamplerYcbcrConversionCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> { + inner: SamplerYcbcrConversionCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> { + type Target = SamplerYcbcrConversionCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn ycbcr_model(mut self, ycbcr_model: SamplerYcbcrModelConversion) -> Self { + self.inner.ycbcr_model = ycbcr_model; + self + } + #[inline] + pub fn ycbcr_range(mut self, ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.ycbcr_range = ycbcr_range; + self + } + #[inline] + pub fn components(mut self, components: ComponentMapping) -> Self { + self.inner.components = components; + self + } + #[inline] + pub fn x_chroma_offset(mut self, x_chroma_offset: ChromaLocation) -> Self { + self.inner.x_chroma_offset = x_chroma_offset; + self + } + #[inline] + pub fn y_chroma_offset(mut self, y_chroma_offset: ChromaLocation) -> Self { + self.inner.y_chroma_offset = y_chroma_offset; + self + } + #[inline] + pub fn chroma_filter(mut self, chroma_filter: Filter) -> Self { + self.inner.chroma_filter = chroma_filter; + self + } + #[inline] + pub fn force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self { + self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerYcbcrConversionCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindImagePlaneMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane_aspect: ImageAspectFlags, +} +impl ::std::default::Default for BindImagePlaneMemoryInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + plane_aspect: ImageAspectFlags::default(), + } + } +} +unsafe impl TaggedStructure for BindImagePlaneMemoryInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_PLANE_MEMORY_INFO; +} +impl BindImagePlaneMemoryInfo { + pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> { + BindImagePlaneMemoryInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindImagePlaneMemoryInfoBuilder<'a> { + inner: BindImagePlaneMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {} +impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> { + type Target = BindImagePlaneMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindImagePlaneMemoryInfoBuilder<'a> { + #[inline] + pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { + self.inner.plane_aspect = plane_aspect; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindImagePlaneMemoryInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImagePlaneMemoryRequirementsInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane_aspect: ImageAspectFlags, +} +impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + plane_aspect: ImageAspectFlags::default(), + } + } +} +unsafe impl TaggedStructure for ImagePlaneMemoryRequirementsInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; +} +impl ImagePlaneMemoryRequirementsInfo { + pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> { + ImagePlaneMemoryRequirementsInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> { + inner: ImagePlaneMemoryRequirementsInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {} +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {} +impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> { + type Target = ImagePlaneMemoryRequirementsInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> { + #[inline] + pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { + self.inner.plane_aspect = plane_aspect; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImagePlaneMemoryRequirementsInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sampler_ycbcr_conversion: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + sampler_ycbcr_conversion: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSamplerYcbcrConversionFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; +} +impl PhysicalDeviceSamplerYcbcrConversionFeatures { + pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + inner: PhysicalDeviceSamplerYcbcrConversionFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + type Target = PhysicalDeviceSamplerYcbcrConversionFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + #[inline] + pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self { + self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerYcbcrConversionImageFormatProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_descriptor_count: u32, +} +impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_descriptor_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for SamplerYcbcrConversionImageFormatProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; +} +impl SamplerYcbcrConversionImageFormatProperties { + pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + SamplerYcbcrConversionImageFormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + inner: SamplerYcbcrConversionImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 + for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + type Target = SamplerYcbcrConversionImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + #[inline] + pub fn combined_image_sampler_descriptor_count( + mut self, + combined_image_sampler_descriptor_count: u32, + ) -> Self { + self.inner.combined_image_sampler_descriptor_count = + combined_image_sampler_descriptor_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct TextureLODGatherFormatPropertiesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supports_texture_gather_lod_bias_amd: Bool32, +} +impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supports_texture_gather_lod_bias_amd: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for TextureLODGatherFormatPropertiesAMD { + const STRUCTURE_TYPE: StructureType = StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; +} +impl TextureLODGatherFormatPropertiesAMD { + pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> { + TextureLODGatherFormatPropertiesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> { + inner: TextureLODGatherFormatPropertiesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {} +impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> { + type Target = TextureLODGatherFormatPropertiesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> { + #[inline] + pub fn supports_texture_gather_lod_bias_amd( + mut self, + supports_texture_gather_lod_bias_amd: bool, + ) -> Self { + self.inner.supports_texture_gather_lod_bias_amd = + supports_texture_gather_lod_bias_amd.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TextureLODGatherFormatPropertiesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ConditionalRenderingBeginInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, + pub offset: DeviceSize, + pub flags: ConditionalRenderingFlagsEXT, +} +impl ::std::default::Default for ConditionalRenderingBeginInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + flags: ConditionalRenderingFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for ConditionalRenderingBeginInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT; +} +impl ConditionalRenderingBeginInfoEXT { + pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> { + ConditionalRenderingBeginInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> { + inner: ConditionalRenderingBeginInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> { + type Target = ConditionalRenderingBeginInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn flags(mut self, flags: ConditionalRenderingFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ConditionalRenderingBeginInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ProtectedSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub protected_submit: Bool32, +} +impl ::std::default::Default for ProtectedSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + protected_submit: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for ProtectedSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PROTECTED_SUBMIT_INFO; +} +impl ProtectedSubmitInfo { + pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> { + ProtectedSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ProtectedSubmitInfoBuilder<'a> { + inner: ProtectedSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {} +impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> { + type Target = ProtectedSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ProtectedSubmitInfoBuilder<'a> { + #[inline] + pub fn protected_submit(mut self, protected_submit: bool) -> Self { + self.inner.protected_submit = protected_submit.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ProtectedSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProtectedMemoryFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub protected_memory: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + protected_memory: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProtectedMemoryFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; +} +impl PhysicalDeviceProtectedMemoryFeatures { + pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + PhysicalDeviceProtectedMemoryFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + inner: PhysicalDeviceProtectedMemoryFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + type Target = PhysicalDeviceProtectedMemoryFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + #[inline] + pub fn protected_memory(mut self, protected_memory: bool) -> Self { + self.inner.protected_memory = protected_memory.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProtectedMemoryProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub protected_no_fault: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + protected_no_fault: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProtectedMemoryProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; +} +impl PhysicalDeviceProtectedMemoryProperties { + pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + PhysicalDeviceProtectedMemoryPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + inner: PhysicalDeviceProtectedMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + type Target = PhysicalDeviceProtectedMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + #[inline] + pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self { + self.inner.protected_no_fault = protected_no_fault.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceQueueInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceQueueCreateFlags, + pub queue_family_index: u32, + pub queue_index: u32, +} +impl ::std::default::Default for DeviceQueueInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceQueueCreateFlags::default(), + queue_family_index: u32::default(), + queue_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for DeviceQueueInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_QUEUE_INFO_2; +} +impl DeviceQueueInfo2 { + pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> { + DeviceQueueInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceQueueInfo2Builder<'a> { + inner: DeviceQueueInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> { + type Target = DeviceQueueInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceQueueInfo2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[inline] + pub fn queue_index(mut self, queue_index: u32) -> Self { + self.inner.queue_index = queue_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceQueueInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCoverageToColorStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCoverageToColorStateCreateFlagsNV, + pub coverage_to_color_enable: Bool32, + pub coverage_to_color_location: u32, +} +impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCoverageToColorStateCreateFlagsNV::default(), + coverage_to_color_enable: Bool32::default(), + coverage_to_color_location: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineCoverageToColorStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; +} +impl PipelineCoverageToColorStateCreateInfoNV { + pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + PipelineCoverageToColorStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + inner: PipelineCoverageToColorStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageToColorStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + type Target = PipelineCoverageToColorStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCoverageToColorStateCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self { + self.inner.coverage_to_color_enable = coverage_to_color_enable.into(); + self + } + #[inline] + pub fn coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self { + self.inner.coverage_to_color_location = coverage_to_color_location; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSamplerFilterMinmaxProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub filter_minmax_single_component_formats: Bool32, + pub filter_minmax_image_component_mapping: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + filter_minmax_single_component_formats: Bool32::default(), + filter_minmax_image_component_mapping: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSamplerFilterMinmaxProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; +} +impl PhysicalDeviceSamplerFilterMinmaxProperties { + pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + inner: PhysicalDeviceSamplerFilterMinmaxProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + type Target = PhysicalDeviceSamplerFilterMinmaxProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + #[inline] + pub fn filter_minmax_single_component_formats( + mut self, + filter_minmax_single_component_formats: bool, + ) -> Self { + self.inner.filter_minmax_single_component_formats = + filter_minmax_single_component_formats.into(); + self + } + #[inline] + pub fn filter_minmax_image_component_mapping( + mut self, + filter_minmax_image_component_mapping: bool, + ) -> Self { + self.inner.filter_minmax_image_component_mapping = + filter_minmax_image_component_mapping.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SampleLocationEXT { + pub x: f32, + pub y: f32, +} +impl SampleLocationEXT { + pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> { + SampleLocationEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SampleLocationEXTBuilder<'a> { + inner: SampleLocationEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> { + type Target = SampleLocationEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SampleLocationEXTBuilder<'a> { + #[inline] + pub fn x(mut self, x: f32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: f32) -> Self { + self.inner.y = y; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SampleLocationEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SampleLocationsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_locations_per_pixel: SampleCountFlags, + pub sample_location_grid_size: Extent2D, + pub sample_locations_count: u32, + pub p_sample_locations: *const SampleLocationEXT, +} +impl ::std::default::Default for SampleLocationsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sample_locations_per_pixel: SampleCountFlags::default(), + sample_location_grid_size: Extent2D::default(), + sample_locations_count: u32::default(), + p_sample_locations: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SampleLocationsInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLE_LOCATIONS_INFO_EXT; +} +impl SampleLocationsInfoEXT { + pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> { + SampleLocationsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SampleLocationsInfoEXTBuilder<'a> { + inner: SampleLocationsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {} +unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT {} +impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> { + type Target = SampleLocationsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SampleLocationsInfoEXTBuilder<'a> { + #[inline] + pub fn sample_locations_per_pixel( + mut self, + sample_locations_per_pixel: SampleCountFlags, + ) -> Self { + self.inner.sample_locations_per_pixel = sample_locations_per_pixel; + self + } + #[inline] + pub fn sample_location_grid_size(mut self, sample_location_grid_size: Extent2D) -> Self { + self.inner.sample_location_grid_size = sample_location_grid_size; + self + } + #[inline] + pub fn sample_locations(mut self, sample_locations: &'a [SampleLocationEXT]) -> Self { + self.inner.sample_locations_count = sample_locations.len() as _; + self.inner.p_sample_locations = sample_locations.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SampleLocationsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AttachmentSampleLocationsEXT { + pub attachment_index: u32, + pub sample_locations_info: SampleLocationsInfoEXT, +} +impl AttachmentSampleLocationsEXT { + pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> { + AttachmentSampleLocationsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentSampleLocationsEXTBuilder<'a> { + inner: AttachmentSampleLocationsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> { + type Target = AttachmentSampleLocationsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentSampleLocationsEXTBuilder<'a> { + #[inline] + pub fn attachment_index(mut self, attachment_index: u32) -> Self { + self.inner.attachment_index = attachment_index; + self + } + #[inline] + pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { + self.inner.sample_locations_info = sample_locations_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentSampleLocationsEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SubpassSampleLocationsEXT { + pub subpass_index: u32, + pub sample_locations_info: SampleLocationsInfoEXT, +} +impl SubpassSampleLocationsEXT { + pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> { + SubpassSampleLocationsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassSampleLocationsEXTBuilder<'a> { + inner: SubpassSampleLocationsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> { + type Target = SubpassSampleLocationsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassSampleLocationsEXTBuilder<'a> { + #[inline] + pub fn subpass_index(mut self, subpass_index: u32) -> Self { + self.inner.subpass_index = subpass_index; + self + } + #[inline] + pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { + self.inner.sample_locations_info = sample_locations_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassSampleLocationsEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSampleLocationsBeginInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_initial_sample_locations_count: u32, + pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT, + pub post_subpass_sample_locations_count: u32, + pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT, +} +impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment_initial_sample_locations_count: u32::default(), + p_attachment_initial_sample_locations: ::std::ptr::null(), + post_subpass_sample_locations_count: u32::default(), + p_post_subpass_sample_locations: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassSampleLocationsBeginInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; +} +impl RenderPassSampleLocationsBeginInfoEXT { + pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + RenderPassSampleLocationsBeginInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + inner: RenderPassSampleLocationsBeginInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + type Target = RenderPassSampleLocationsBeginInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + #[inline] + pub fn attachment_initial_sample_locations( + mut self, + attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT], + ) -> Self { + self.inner.attachment_initial_sample_locations_count = + attachment_initial_sample_locations.len() as _; + self.inner.p_attachment_initial_sample_locations = + attachment_initial_sample_locations.as_ptr(); + self + } + #[inline] + pub fn post_subpass_sample_locations( + mut self, + post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT], + ) -> Self { + self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _; + self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineSampleLocationsStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_locations_enable: Bool32, + pub sample_locations_info: SampleLocationsInfoEXT, +} +impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sample_locations_enable: Bool32::default(), + sample_locations_info: SampleLocationsInfoEXT::default(), + } + } +} +unsafe impl TaggedStructure for PipelineSampleLocationsStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; +} +impl PipelineSampleLocationsStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + PipelineSampleLocationsStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + inner: PipelineSampleLocationsStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineSampleLocationsStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + type Target = PipelineSampleLocationsStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self { + self.inner.sample_locations_enable = sample_locations_enable.into(); + self + } + #[inline] + pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { + self.inner.sample_locations_info = sample_locations_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSampleLocationsPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sample_location_sample_counts: SampleCountFlags, + pub max_sample_location_grid_size: Extent2D, + pub sample_location_coordinate_range: [f32; 2], + pub sample_location_sub_pixel_bits: u32, + pub variable_sample_locations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + sample_location_sample_counts: SampleCountFlags::default(), + max_sample_location_grid_size: Extent2D::default(), + sample_location_coordinate_range: unsafe { ::std::mem::zeroed() }, + sample_location_sub_pixel_bits: u32::default(), + variable_sample_locations: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSampleLocationsPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; +} +impl PhysicalDeviceSampleLocationsPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + PhysicalDeviceSampleLocationsPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceSampleLocationsPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceSampleLocationsPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + #[inline] + pub fn sample_location_sample_counts( + mut self, + sample_location_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sample_location_sample_counts = sample_location_sample_counts; + self + } + #[inline] + pub fn max_sample_location_grid_size( + mut self, + max_sample_location_grid_size: Extent2D, + ) -> Self { + self.inner.max_sample_location_grid_size = max_sample_location_grid_size; + self + } + #[inline] + pub fn sample_location_coordinate_range( + mut self, + sample_location_coordinate_range: [f32; 2], + ) -> Self { + self.inner.sample_location_coordinate_range = sample_location_coordinate_range; + self + } + #[inline] + pub fn sample_location_sub_pixel_bits(mut self, sample_location_sub_pixel_bits: u32) -> Self { + self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits; + self + } + #[inline] + pub fn variable_sample_locations(mut self, variable_sample_locations: bool) -> Self { + self.inner.variable_sample_locations = variable_sample_locations.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MultisamplePropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_sample_location_grid_size: Extent2D, +} +impl ::std::default::Default for MultisamplePropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_sample_location_grid_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for MultisamplePropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MULTISAMPLE_PROPERTIES_EXT; +} +impl MultisamplePropertiesEXT { + pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> { + MultisamplePropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultisamplePropertiesEXTBuilder<'a> { + inner: MultisamplePropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> { + type Target = MultisamplePropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultisamplePropertiesEXTBuilder<'a> { + #[inline] + pub fn max_sample_location_grid_size( + mut self, + max_sample_location_grid_size: Extent2D, + ) -> Self { + self.inner.max_sample_location_grid_size = max_sample_location_grid_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultisamplePropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerReductionModeCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub reduction_mode: SamplerReductionMode, +} +impl ::std::default::Default for SamplerReductionModeCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + reduction_mode: SamplerReductionMode::default(), + } + } +} +unsafe impl TaggedStructure for SamplerReductionModeCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO; +} +impl SamplerReductionModeCreateInfo { + pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> { + SamplerReductionModeCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerReductionModeCreateInfoBuilder<'a> { + inner: SamplerReductionModeCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo {} +impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> { + type Target = SamplerReductionModeCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerReductionModeCreateInfoBuilder<'a> { + #[inline] + pub fn reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self { + self.inner.reduction_mode = reduction_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerReductionModeCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub advanced_blend_coherent_operations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + advanced_blend_coherent_operations: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; +} +impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + #[inline] + pub fn advanced_blend_coherent_operations( + mut self, + advanced_blend_coherent_operations: bool, + ) -> Self { + self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiDrawFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multi_draw: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultiDrawFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multi_draw: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiDrawFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; +} +impl PhysicalDeviceMultiDrawFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + PhysicalDeviceMultiDrawFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMultiDrawFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMultiDrawFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + #[inline] + pub fn multi_draw(mut self, multi_draw: bool) -> Self { + self.inner.multi_draw = multi_draw.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiDrawFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub advanced_blend_max_color_attachments: u32, + pub advanced_blend_independent_blend: Bool32, + pub advanced_blend_non_premultiplied_src_color: Bool32, + pub advanced_blend_non_premultiplied_dst_color: Bool32, + pub advanced_blend_correlated_overlap: Bool32, + pub advanced_blend_all_operations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + advanced_blend_max_color_attachments: u32::default(), + advanced_blend_independent_blend: Bool32::default(), + advanced_blend_non_premultiplied_src_color: Bool32::default(), + advanced_blend_non_premultiplied_dst_color: Bool32::default(), + advanced_blend_correlated_overlap: Bool32::default(), + advanced_blend_all_operations: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; +} +impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + #[inline] + pub fn advanced_blend_max_color_attachments( + mut self, + advanced_blend_max_color_attachments: u32, + ) -> Self { + self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments; + self + } + #[inline] + pub fn advanced_blend_independent_blend( + mut self, + advanced_blend_independent_blend: bool, + ) -> Self { + self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into(); + self + } + #[inline] + pub fn advanced_blend_non_premultiplied_src_color( + mut self, + advanced_blend_non_premultiplied_src_color: bool, + ) -> Self { + self.inner.advanced_blend_non_premultiplied_src_color = + advanced_blend_non_premultiplied_src_color.into(); + self + } + #[inline] + pub fn advanced_blend_non_premultiplied_dst_color( + mut self, + advanced_blend_non_premultiplied_dst_color: bool, + ) -> Self { + self.inner.advanced_blend_non_premultiplied_dst_color = + advanced_blend_non_premultiplied_dst_color.into(); + self + } + #[inline] + pub fn advanced_blend_correlated_overlap( + mut self, + advanced_blend_correlated_overlap: bool, + ) -> Self { + self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into(); + self + } + #[inline] + pub fn advanced_blend_all_operations(mut self, advanced_blend_all_operations: bool) -> Self { + self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_premultiplied: Bool32, + pub dst_premultiplied: Bool32, + pub blend_overlap: BlendOverlapEXT, +} +impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_premultiplied: Bool32::default(), + dst_premultiplied: Bool32::default(), + blend_overlap: BlendOverlapEXT::default(), + } + } +} +unsafe impl TaggedStructure for PipelineColorBlendAdvancedStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; +} +impl PipelineColorBlendAdvancedStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + PipelineColorBlendAdvancedStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + inner: PipelineColorBlendAdvancedStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo + for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo + for PipelineColorBlendAdvancedStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + type Target = PipelineColorBlendAdvancedStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self { + self.inner.src_premultiplied = src_premultiplied.into(); + self + } + #[inline] + pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self { + self.inner.dst_premultiplied = dst_premultiplied.into(); + self + } + #[inline] + pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self { + self.inner.blend_overlap = blend_overlap; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceInlineUniformBlockFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub inline_uniform_block: Bool32, + pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32, +} +impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + inline_uniform_block: Bool32::default(), + descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceInlineUniformBlockFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; +} +impl PhysicalDeviceInlineUniformBlockFeatures { + pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + PhysicalDeviceInlineUniformBlockFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + inner: PhysicalDeviceInlineUniformBlockFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + type Target = PhysicalDeviceInlineUniformBlockFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + #[inline] + pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self { + self.inner.inline_uniform_block = inline_uniform_block.into(); + self + } + #[inline] + pub fn descriptor_binding_inline_uniform_block_update_after_bind( + mut self, + descriptor_binding_inline_uniform_block_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_inline_uniform_block_update_after_bind = + descriptor_binding_inline_uniform_block_update_after_bind.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceInlineUniformBlockProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_inline_uniform_block_size: u32, + pub max_per_stage_descriptor_inline_uniform_blocks: u32, + pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + pub max_descriptor_set_inline_uniform_blocks: u32, + pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, +} +impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_inline_uniform_block_size: u32::default(), + max_per_stage_descriptor_inline_uniform_blocks: u32::default(), + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(), + max_descriptor_set_inline_uniform_blocks: u32::default(), + max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceInlineUniformBlockProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; +} +impl PhysicalDeviceInlineUniformBlockProperties { + pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + PhysicalDeviceInlineUniformBlockPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + inner: PhysicalDeviceInlineUniformBlockProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + type Target = PhysicalDeviceInlineUniformBlockProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + #[inline] + pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self { + self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size; + self + } + #[inline] + pub fn max_per_stage_descriptor_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_inline_uniform_blocks: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_inline_uniform_blocks = + max_per_stage_descriptor_inline_uniform_blocks; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks; + self + } + #[inline] + pub fn max_descriptor_set_inline_uniform_blocks( + mut self, + max_descriptor_set_inline_uniform_blocks: u32, + ) -> Self { + self.inner.max_descriptor_set_inline_uniform_blocks = + max_descriptor_set_inline_uniform_blocks; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks( + mut self, + max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_inline_uniform_blocks = + max_descriptor_set_update_after_bind_inline_uniform_blocks; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceInlineUniformBlockProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WriteDescriptorSetInlineUniformBlock { + pub s_type: StructureType, + pub p_next: *const c_void, + pub data_size: u32, + pub p_data: *const c_void, +} +impl ::std::default::Default for WriteDescriptorSetInlineUniformBlock { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + data_size: u32::default(), + p_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for WriteDescriptorSetInlineUniformBlock { + const STRUCTURE_TYPE: StructureType = StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; +} +impl WriteDescriptorSetInlineUniformBlock { + pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a> { + WriteDescriptorSetInlineUniformBlockBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WriteDescriptorSetInlineUniformBlockBuilder<'a> { + inner: WriteDescriptorSetInlineUniformBlock, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockBuilder<'a> { + type Target = WriteDescriptorSetInlineUniformBlock; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WriteDescriptorSetInlineUniformBlockBuilder<'a> { + #[inline] + pub fn data(mut self, data: &'a [u8]) -> Self { + self.inner.data_size = data.len() as _; + self.inner.p_data = data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WriteDescriptorSetInlineUniformBlock { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorPoolInlineUniformBlockCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_inline_uniform_block_bindings: u32, +} +impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_inline_uniform_block_bindings: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorPoolInlineUniformBlockCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; +} +impl DescriptorPoolInlineUniformBlockCreateInfo { + pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + DescriptorPoolInlineUniformBlockCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + inner: DescriptorPoolInlineUniformBlockCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorPoolCreateInfo + for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo {} +impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + type Target = DescriptorPoolInlineUniformBlockCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + #[inline] + pub fn max_inline_uniform_block_bindings( + mut self, + max_inline_uniform_block_bindings: u32, + ) -> Self { + self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCoverageModulationStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCoverageModulationStateCreateFlagsNV, + pub coverage_modulation_mode: CoverageModulationModeNV, + pub coverage_modulation_table_enable: Bool32, + pub coverage_modulation_table_count: u32, + pub p_coverage_modulation_table: *const f32, +} +impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCoverageModulationStateCreateFlagsNV::default(), + coverage_modulation_mode: CoverageModulationModeNV::default(), + coverage_modulation_table_enable: Bool32::default(), + coverage_modulation_table_count: u32::default(), + p_coverage_modulation_table: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineCoverageModulationStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; +} +impl PipelineCoverageModulationStateCreateInfoNV { + pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + PipelineCoverageModulationStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + inner: PipelineCoverageModulationStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageModulationStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageModulationStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + type Target = PipelineCoverageModulationStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCoverageModulationStateCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn coverage_modulation_mode( + mut self, + coverage_modulation_mode: CoverageModulationModeNV, + ) -> Self { + self.inner.coverage_modulation_mode = coverage_modulation_mode; + self + } + #[inline] + pub fn coverage_modulation_table_enable( + mut self, + coverage_modulation_table_enable: bool, + ) -> Self { + self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into(); + self + } + #[inline] + pub fn coverage_modulation_table(mut self, coverage_modulation_table: &'a [f32]) -> Self { + self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _; + self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageFormatListCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub view_format_count: u32, + pub p_view_formats: *const Format, +} +impl ::std::default::Default for ImageFormatListCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + view_format_count: u32::default(), + p_view_formats: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ImageFormatListCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_LIST_CREATE_INFO; +} +impl ImageFormatListCreateInfo { + pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> { + ImageFormatListCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatListCreateInfoBuilder<'a> { + inner: ImageFormatListCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo {} +impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoBuilder<'a> { + type Target = ImageFormatListCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatListCreateInfoBuilder<'a> { + #[inline] + pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self { + self.inner.view_format_count = view_formats.len() as _; + self.inner.p_view_formats = view_formats.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatListCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ValidationCacheCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ValidationCacheCreateFlagsEXT, + pub initial_data_size: usize, + pub p_initial_data: *const c_void, +} +impl ::std::default::Default for ValidationCacheCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ValidationCacheCreateFlagsEXT::default(), + initial_data_size: usize::default(), + p_initial_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ValidationCacheCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_CACHE_CREATE_INFO_EXT; +} +impl ValidationCacheCreateInfoEXT { + pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> { + ValidationCacheCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ValidationCacheCreateInfoEXTBuilder<'a> { + inner: ValidationCacheCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> { + type Target = ValidationCacheCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ValidationCacheCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self { + self.inner.initial_data_size = initial_data.len(); + self.inner.p_initial_data = initial_data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ValidationCacheCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderModuleValidationCacheCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub validation_cache: ValidationCacheEXT, +} +impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + validation_cache: ValidationCacheEXT::default(), + } + } +} +unsafe impl TaggedStructure for ShaderModuleValidationCacheCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; +} +impl ShaderModuleValidationCacheCreateInfoEXT { + pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + ShaderModuleValidationCacheCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + inner: ShaderModuleValidationCacheCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + type Target = ShaderModuleValidationCacheCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + #[inline] + pub fn validation_cache(mut self, validation_cache: ValidationCacheEXT) -> Self { + self.inner.validation_cache = validation_cache; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance3Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_per_set_descriptors: u32, + pub max_memory_allocation_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_per_set_descriptors: u32::default(), + max_memory_allocation_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMaintenance3Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; +} +impl PhysicalDeviceMaintenance3Properties { + pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + PhysicalDeviceMaintenance3PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + inner: PhysicalDeviceMaintenance3Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + type Target = PhysicalDeviceMaintenance3Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + #[inline] + pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self { + self.inner.max_per_set_descriptors = max_per_set_descriptors; + self + } + #[inline] + pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self { + self.inner.max_memory_allocation_size = max_memory_allocation_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMaintenance3Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance4Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub maintenance4: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMaintenance4Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + maintenance4: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMaintenance4Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; +} +impl PhysicalDeviceMaintenance4Features { + pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + PhysicalDeviceMaintenance4FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + inner: PhysicalDeviceMaintenance4Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + type Target = PhysicalDeviceMaintenance4Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + #[inline] + pub fn maintenance4(mut self, maintenance4: bool) -> Self { + self.inner.maintenance4 = maintenance4.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMaintenance4Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance4Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_buffer_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceMaintenance4Properties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_buffer_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMaintenance4Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; +} +impl PhysicalDeviceMaintenance4Properties { + pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + PhysicalDeviceMaintenance4PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + inner: PhysicalDeviceMaintenance4Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + type Target = PhysicalDeviceMaintenance4Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + #[inline] + pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self { + self.inner.max_buffer_size = max_buffer_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMaintenance4Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutSupport { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported: Bool32, +} +impl ::std::default::Default for DescriptorSetLayoutSupport { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetLayoutSupport { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT; +} +impl DescriptorSetLayoutSupport { + pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> { + DescriptorSetLayoutSupportBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutSupportBuilder<'a> { + inner: DescriptorSetLayoutSupport, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorSetLayoutSupport {} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> { + type Target = DescriptorSetLayoutSupport; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutSupportBuilder<'a> { + #[inline] + pub fn supported(mut self, supported: bool) -> Self { + self.inner.supported = supported.into(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutSupport { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderDrawParametersFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_draw_parameters: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_draw_parameters: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderDrawParametersFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; +} +impl PhysicalDeviceShaderDrawParametersFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + PhysicalDeviceShaderDrawParametersFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderDrawParametersFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderDrawParametersFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + #[inline] + pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self { + self.inner.shader_draw_parameters = shader_draw_parameters.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderDrawParametersFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderFloat16Int8Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_float16: Bool32, + pub shader_int8: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_float16: Bool32::default(), + shader_int8: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderFloat16Int8Features { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; +} +impl PhysicalDeviceShaderFloat16Int8Features { + pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + PhysicalDeviceShaderFloat16Int8FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + inner: PhysicalDeviceShaderFloat16Int8Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderFloat16Int8Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + #[inline] + pub fn shader_float16(mut self, shader_float16: bool) -> Self { + self.inner.shader_float16 = shader_float16.into(); + self + } + #[inline] + pub fn shader_int8(mut self, shader_int8: bool) -> Self { + self.inner.shader_int8 = shader_int8.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderFloat16Int8Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFloatControlsProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub denorm_behavior_independence: ShaderFloatControlsIndependence, + pub rounding_mode_independence: ShaderFloatControlsIndependence, + pub shader_signed_zero_inf_nan_preserve_float16: Bool32, + pub shader_signed_zero_inf_nan_preserve_float32: Bool32, + pub shader_signed_zero_inf_nan_preserve_float64: Bool32, + pub shader_denorm_preserve_float16: Bool32, + pub shader_denorm_preserve_float32: Bool32, + pub shader_denorm_preserve_float64: Bool32, + pub shader_denorm_flush_to_zero_float16: Bool32, + pub shader_denorm_flush_to_zero_float32: Bool32, + pub shader_denorm_flush_to_zero_float64: Bool32, + pub shader_rounding_mode_rte_float16: Bool32, + pub shader_rounding_mode_rte_float32: Bool32, + pub shader_rounding_mode_rte_float64: Bool32, + pub shader_rounding_mode_rtz_float16: Bool32, + pub shader_rounding_mode_rtz_float32: Bool32, + pub shader_rounding_mode_rtz_float64: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFloatControlsProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + denorm_behavior_independence: ShaderFloatControlsIndependence::default(), + rounding_mode_independence: ShaderFloatControlsIndependence::default(), + shader_signed_zero_inf_nan_preserve_float16: Bool32::default(), + shader_signed_zero_inf_nan_preserve_float32: Bool32::default(), + shader_signed_zero_inf_nan_preserve_float64: Bool32::default(), + shader_denorm_preserve_float16: Bool32::default(), + shader_denorm_preserve_float32: Bool32::default(), + shader_denorm_preserve_float64: Bool32::default(), + shader_denorm_flush_to_zero_float16: Bool32::default(), + shader_denorm_flush_to_zero_float32: Bool32::default(), + shader_denorm_flush_to_zero_float64: Bool32::default(), + shader_rounding_mode_rte_float16: Bool32::default(), + shader_rounding_mode_rte_float32: Bool32::default(), + shader_rounding_mode_rte_float64: Bool32::default(), + shader_rounding_mode_rtz_float16: Bool32::default(), + shader_rounding_mode_rtz_float32: Bool32::default(), + shader_rounding_mode_rtz_float64: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFloatControlsProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; +} +impl PhysicalDeviceFloatControlsProperties { + pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + PhysicalDeviceFloatControlsPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + inner: PhysicalDeviceFloatControlsProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + type Target = PhysicalDeviceFloatControlsProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + #[inline] + pub fn denorm_behavior_independence( + mut self, + denorm_behavior_independence: ShaderFloatControlsIndependence, + ) -> Self { + self.inner.denorm_behavior_independence = denorm_behavior_independence; + self + } + #[inline] + pub fn rounding_mode_independence( + mut self, + rounding_mode_independence: ShaderFloatControlsIndependence, + ) -> Self { + self.inner.rounding_mode_independence = rounding_mode_independence; + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float16( + mut self, + shader_signed_zero_inf_nan_preserve_float16: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float16 = + shader_signed_zero_inf_nan_preserve_float16.into(); + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float32( + mut self, + shader_signed_zero_inf_nan_preserve_float32: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float32 = + shader_signed_zero_inf_nan_preserve_float32.into(); + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float64( + mut self, + shader_signed_zero_inf_nan_preserve_float64: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float64 = + shader_signed_zero_inf_nan_preserve_float64.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self { + self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self { + self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self { + self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float16( + mut self, + shader_denorm_flush_to_zero_float16: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float32( + mut self, + shader_denorm_flush_to_zero_float32: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float64( + mut self, + shader_denorm_flush_to_zero_float64: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float16( + mut self, + shader_rounding_mode_rte_float16: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float32( + mut self, + shader_rounding_mode_rte_float32: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float64( + mut self, + shader_rounding_mode_rte_float64: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float16( + mut self, + shader_rounding_mode_rtz_float16: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float32( + mut self, + shader_rounding_mode_rtz_float32: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float64( + mut self, + shader_rounding_mode_rtz_float64: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFloatControlsProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceHostQueryResetFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub host_query_reset: Bool32, +} +impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + host_query_reset: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceHostQueryResetFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; +} +impl PhysicalDeviceHostQueryResetFeatures { + pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + PhysicalDeviceHostQueryResetFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + inner: PhysicalDeviceHostQueryResetFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + type Target = PhysicalDeviceHostQueryResetFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + #[inline] + pub fn host_query_reset(mut self, host_query_reset: bool) -> Self { + self.inner.host_query_reset = host_query_reset.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceHostQueryResetFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct NativeBufferUsage2ANDROID { + pub consumer: u64, + pub producer: u64, +} +impl NativeBufferUsage2ANDROID { + pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> { + NativeBufferUsage2ANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct NativeBufferUsage2ANDROIDBuilder<'a> { + inner: NativeBufferUsage2ANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for NativeBufferUsage2ANDROIDBuilder<'a> { + type Target = NativeBufferUsage2ANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> { + #[inline] + pub fn consumer(mut self, consumer: u64) -> Self { + self.inner.consumer = consumer; + self + } + #[inline] + pub fn producer(mut self, producer: u64) -> Self { + self.inner.producer = producer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> NativeBufferUsage2ANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct NativeBufferANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle: *const c_void, + pub stride: c_int, + pub format: c_int, + pub usage: c_int, + pub usage2: NativeBufferUsage2ANDROID, +} +impl ::std::default::Default for NativeBufferANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle: ::std::ptr::null(), + stride: c_int::default(), + format: c_int::default(), + usage: c_int::default(), + usage2: NativeBufferUsage2ANDROID::default(), + } + } +} +unsafe impl TaggedStructure for NativeBufferANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::NATIVE_BUFFER_ANDROID; +} +impl NativeBufferANDROID { + pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> { + NativeBufferANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct NativeBufferANDROIDBuilder<'a> { + inner: NativeBufferANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> { + type Target = NativeBufferANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> NativeBufferANDROIDBuilder<'a> { + #[inline] + pub fn handle(mut self, handle: *const c_void) -> Self { + self.inner.handle = handle; + self + } + #[inline] + pub fn stride(mut self, stride: c_int) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn format(mut self, format: c_int) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn usage(mut self, usage: c_int) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> Self { + self.inner.usage2 = usage2; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> NativeBufferANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainImageCreateInfoANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: SwapchainImageUsageFlagsANDROID, +} +impl ::std::default::Default for SwapchainImageCreateInfoANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + usage: SwapchainImageUsageFlagsANDROID::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainImageCreateInfoANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID; +} +impl SwapchainImageCreateInfoANDROID { + pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> { + SwapchainImageCreateInfoANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> { + inner: SwapchainImageCreateInfoANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> { + type Target = SwapchainImageCreateInfoANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> { + #[inline] + pub fn usage(mut self, usage: SwapchainImageUsageFlagsANDROID) -> Self { + self.inner.usage = usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainImageCreateInfoANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentationPropertiesANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shared_image: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + shared_image: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePresentationPropertiesANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID; +} +impl PhysicalDevicePresentationPropertiesANDROID { + pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + PhysicalDevicePresentationPropertiesANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + inner: PhysicalDevicePresentationPropertiesANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + type Target = PhysicalDevicePresentationPropertiesANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + #[inline] + pub fn shared_image(mut self, shared_image: bool) -> Self { + self.inner.shared_image = shared_image.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePresentationPropertiesANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ShaderResourceUsageAMD { + pub num_used_vgprs: u32, + pub num_used_sgprs: u32, + pub lds_size_per_local_work_group: u32, + pub lds_usage_size_in_bytes: usize, + pub scratch_mem_usage_in_bytes: usize, +} +impl ShaderResourceUsageAMD { + pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> { + ShaderResourceUsageAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderResourceUsageAMDBuilder<'a> { + inner: ShaderResourceUsageAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> { + type Target = ShaderResourceUsageAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderResourceUsageAMDBuilder<'a> { + #[inline] + pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> Self { + self.inner.num_used_vgprs = num_used_vgprs; + self + } + #[inline] + pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> Self { + self.inner.num_used_sgprs = num_used_sgprs; + self + } + #[inline] + pub fn lds_size_per_local_work_group(mut self, lds_size_per_local_work_group: u32) -> Self { + self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group; + self + } + #[inline] + pub fn lds_usage_size_in_bytes(mut self, lds_usage_size_in_bytes: usize) -> Self { + self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes; + self + } + #[inline] + pub fn scratch_mem_usage_in_bytes(mut self, scratch_mem_usage_in_bytes: usize) -> Self { + self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderResourceUsageAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderStatisticsInfoAMD { + pub shader_stage_mask: ShaderStageFlags, + pub resource_usage: ShaderResourceUsageAMD, + pub num_physical_vgprs: u32, + pub num_physical_sgprs: u32, + pub num_available_vgprs: u32, + pub num_available_sgprs: u32, + pub compute_work_group_size: [u32; 3], +} +impl ::std::default::Default for ShaderStatisticsInfoAMD { + #[inline] + fn default() -> Self { + Self { + shader_stage_mask: ShaderStageFlags::default(), + resource_usage: ShaderResourceUsageAMD::default(), + num_physical_vgprs: u32::default(), + num_physical_sgprs: u32::default(), + num_available_vgprs: u32::default(), + num_available_sgprs: u32::default(), + compute_work_group_size: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ShaderStatisticsInfoAMD { + pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> { + ShaderStatisticsInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderStatisticsInfoAMDBuilder<'a> { + inner: ShaderStatisticsInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> { + type Target = ShaderStatisticsInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderStatisticsInfoAMDBuilder<'a> { + #[inline] + pub fn shader_stage_mask(mut self, shader_stage_mask: ShaderStageFlags) -> Self { + self.inner.shader_stage_mask = shader_stage_mask; + self + } + #[inline] + pub fn resource_usage(mut self, resource_usage: ShaderResourceUsageAMD) -> Self { + self.inner.resource_usage = resource_usage; + self + } + #[inline] + pub fn num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self { + self.inner.num_physical_vgprs = num_physical_vgprs; + self + } + #[inline] + pub fn num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self { + self.inner.num_physical_sgprs = num_physical_sgprs; + self + } + #[inline] + pub fn num_available_vgprs(mut self, num_available_vgprs: u32) -> Self { + self.inner.num_available_vgprs = num_available_vgprs; + self + } + #[inline] + pub fn num_available_sgprs(mut self, num_available_sgprs: u32) -> Self { + self.inner.num_available_sgprs = num_available_sgprs; + self + } + #[inline] + pub fn compute_work_group_size(mut self, compute_work_group_size: [u32; 3]) -> Self { + self.inner.compute_work_group_size = compute_work_group_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderStatisticsInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceQueueGlobalPriorityCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub global_priority: QueueGlobalPriorityKHR, +} +impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + global_priority: QueueGlobalPriorityKHR::default(), + } + } +} +unsafe impl TaggedStructure for DeviceQueueGlobalPriorityCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR; +} +impl DeviceQueueGlobalPriorityCreateInfoKHR { + pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + DeviceQueueGlobalPriorityCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + inner: DeviceQueueGlobalPriorityCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHR {} +impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + type Target = DeviceQueueGlobalPriorityCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + #[inline] + pub fn global_priority(mut self, global_priority: QueueGlobalPriorityKHR) -> Self { + self.inner.global_priority = global_priority; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub global_priority_query: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + global_priority_query: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR; +} +impl PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceGlobalPriorityQueryFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceGlobalPriorityQueryFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + #[inline] + pub fn global_priority_query(mut self, global_priority_query: bool) -> Self { + self.inner.global_priority_query = global_priority_query.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyGlobalPriorityPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub priority_count: u32, + pub priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR], +} +impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + priority_count: u32::default(), + priorities: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for QueueFamilyGlobalPriorityPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR; +} +impl QueueFamilyGlobalPriorityPropertiesKHR { + pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + QueueFamilyGlobalPriorityPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + inner: QueueFamilyGlobalPriorityPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHR {} +impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + type Target = QueueFamilyGlobalPriorityPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + #[inline] + pub fn priority_count(mut self, priority_count: u32) -> Self { + self.inner.priority_count = priority_count; + self + } + #[inline] + pub fn priorities( + mut self, + priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR], + ) -> Self { + self.inner.priorities = priorities; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsObjectNameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: ObjectType, + pub object_handle: u64, + pub p_object_name: *const c_char, +} +impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + object_type: ObjectType::default(), + object_handle: u64::default(), + p_object_name: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugUtilsObjectNameInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT; +} +impl DebugUtilsObjectNameInfoEXT { + pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> { + DebugUtilsObjectNameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> { + inner: DebugUtilsObjectNameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXTBuilder<'_> {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXT {} +impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> { + type Target = DebugUtilsObjectNameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { + #[inline] + pub fn object_type(mut self, object_type: ObjectType) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.inner.object_handle = object_handle; + self + } + #[inline] + pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_object_name = object_name.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsObjectNameInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsObjectTagInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: ObjectType, + pub object_handle: u64, + pub tag_name: u64, + pub tag_size: usize, + pub p_tag: *const c_void, +} +impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + object_type: ObjectType::default(), + object_handle: u64::default(), + tag_name: u64::default(), + tag_size: usize::default(), + p_tag: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugUtilsObjectTagInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT; +} +impl DebugUtilsObjectTagInfoEXT { + pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + DebugUtilsObjectTagInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> { + inner: DebugUtilsObjectTagInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> { + type Target = DebugUtilsObjectTagInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { + #[inline] + pub fn object_type(mut self, object_type: ObjectType) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.inner.object_handle = object_handle; + self + } + #[inline] + pub fn tag_name(mut self, tag_name: u64) -> Self { + self.inner.tag_name = tag_name; + self + } + #[inline] + pub fn tag(mut self, tag: &'a [u8]) -> Self { + self.inner.tag_size = tag.len(); + self.inner.p_tag = tag.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsObjectTagInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsLabelEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_label_name: *const c_char, + pub color: [f32; 4], +} +impl ::std::default::Default for DebugUtilsLabelEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_label_name: ::std::ptr::null(), + color: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for DebugUtilsLabelEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_LABEL_EXT; +} +impl DebugUtilsLabelEXT { + pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> { + DebugUtilsLabelEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsLabelEXTBuilder<'a> { + inner: DebugUtilsLabelEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> { + type Target = DebugUtilsLabelEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsLabelEXTBuilder<'a> { + #[inline] + pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_label_name = label_name.as_ptr(); + self + } + #[inline] + pub fn color(mut self, color: [f32; 4]) -> Self { + self.inner.color = color; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsLabelEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsMessengerCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugUtilsMessengerCreateFlagsEXT, + pub message_severity: DebugUtilsMessageSeverityFlagsEXT, + pub message_type: DebugUtilsMessageTypeFlagsEXT, + pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, + pub p_user_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("message_severity", &self.message_severity) + .field("message_type", &self.message_type) + .field( + "pfn_user_callback", + &(self.pfn_user_callback.map(|x| x as *const ())), + ) + .field("p_user_data", &self.p_user_data) + .finish() + } +} +impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DebugUtilsMessengerCreateFlagsEXT::default(), + message_severity: DebugUtilsMessageSeverityFlagsEXT::default(), + message_type: DebugUtilsMessageTypeFlagsEXT::default(), + pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DebugUtilsMessengerCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; +} +impl DebugUtilsMessengerCreateInfoEXT { + pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + DebugUtilsMessengerCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + inner: DebugUtilsMessengerCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + type Target = DebugUtilsMessengerCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DebugUtilsMessengerCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn message_severity(mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT) -> Self { + self.inner.message_severity = message_severity; + self + } + #[inline] + pub fn message_type(mut self, message_type: DebugUtilsMessageTypeFlagsEXT) -> Self { + self.inner.message_type = message_type; + self + } + #[inline] + pub fn pfn_user_callback( + mut self, + pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, + ) -> Self { + self.inner.pfn_user_callback = pfn_user_callback; + self + } + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsMessengerCallbackDataEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugUtilsMessengerCallbackDataFlagsEXT, + pub p_message_id_name: *const c_char, + pub message_id_number: i32, + pub p_message: *const c_char, + pub queue_label_count: u32, + pub p_queue_labels: *const DebugUtilsLabelEXT, + pub cmd_buf_label_count: u32, + pub p_cmd_buf_labels: *const DebugUtilsLabelEXT, + pub object_count: u32, + pub p_objects: *const DebugUtilsObjectNameInfoEXT, +} +impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(), + p_message_id_name: ::std::ptr::null(), + message_id_number: i32::default(), + p_message: ::std::ptr::null(), + queue_label_count: u32::default(), + p_queue_labels: ::std::ptr::null(), + cmd_buf_label_count: u32::default(), + p_cmd_buf_labels: ::std::ptr::null(), + object_count: u32::default(), + p_objects: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugUtilsMessengerCallbackDataEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; +} +impl DebugUtilsMessengerCallbackDataEXT { + pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + DebugUtilsMessengerCallbackDataEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + inner: DebugUtilsMessengerCallbackDataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {} +impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + type Target = DebugUtilsMessengerCallbackDataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn message_id_name(mut self, message_id_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_message_id_name = message_id_name.as_ptr(); + self + } + #[inline] + pub fn message_id_number(mut self, message_id_number: i32) -> Self { + self.inner.message_id_number = message_id_number; + self + } + #[inline] + pub fn message(mut self, message: &'a ::std::ffi::CStr) -> Self { + self.inner.p_message = message.as_ptr(); + self + } + #[inline] + pub fn queue_labels(mut self, queue_labels: &'a [DebugUtilsLabelEXT]) -> Self { + self.inner.queue_label_count = queue_labels.len() as _; + self.inner.p_queue_labels = queue_labels.as_ptr(); + self + } + #[inline] + pub fn cmd_buf_labels(mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT]) -> Self { + self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _; + self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr(); + self + } + #[inline] + pub fn objects(mut self, objects: &'a [DebugUtilsObjectNameInfoEXT]) -> Self { + self.inner.object_count = objects.len() as _; + self.inner.p_objects = objects.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_memory_report: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_memory_report: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDeviceMemoryReportFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; +} +impl PhysicalDeviceDeviceMemoryReportFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + #[inline] + pub fn device_memory_report(mut self, device_memory_report: bool) -> Self { + self.inner.device_memory_report = device_memory_report.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceDeviceMemoryReportCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceMemoryReportFlagsEXT, + pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, + pub p_user_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field( + "pfn_user_callback", + &(self.pfn_user_callback.map(|x| x as *const ())), + ) + .field("p_user_data", &self.p_user_data) + .finish() + } +} +impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceMemoryReportFlagsEXT::default(), + pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DeviceDeviceMemoryReportCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; +} +impl DeviceDeviceMemoryReportCreateInfoEXT { + pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + DeviceDeviceMemoryReportCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + inner: DeviceDeviceMemoryReportCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + type Target = DeviceDeviceMemoryReportCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pfn_user_callback( + mut self, + pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, + ) -> Self { + self.inner.pfn_user_callback = pfn_user_callback; + self + } + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceDeviceMemoryReportCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceMemoryReportCallbackDataEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: DeviceMemoryReportFlagsEXT, + pub ty: DeviceMemoryReportEventTypeEXT, + pub memory_object_id: u64, + pub size: DeviceSize, + pub object_type: ObjectType, + pub object_handle: u64, + pub heap_index: u32, +} +impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: DeviceMemoryReportFlagsEXT::default(), + ty: DeviceMemoryReportEventTypeEXT::default(), + memory_object_id: u64::default(), + size: DeviceSize::default(), + object_type: ObjectType::default(), + object_handle: u64::default(), + heap_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for DeviceMemoryReportCallbackDataEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; +} +impl DeviceMemoryReportCallbackDataEXT { + pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + DeviceMemoryReportCallbackDataEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> { + inner: DeviceMemoryReportCallbackDataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> { + type Target = DeviceMemoryReportCallbackDataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn ty(mut self, ty: DeviceMemoryReportEventTypeEXT) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn memory_object_id(mut self, memory_object_id: u64) -> Self { + self.inner.memory_object_id = memory_object_id; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn object_type(mut self, object_type: ObjectType) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.inner.object_handle = object_handle; + self + } + #[inline] + pub fn heap_index(mut self, heap_index: u32) -> Self { + self.inner.heap_index = heap_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceMemoryReportCallbackDataEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryHostPointerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub p_host_pointer: *mut c_void, +} +impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + p_host_pointer: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ImportMemoryHostPointerInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT; +} +impl ImportMemoryHostPointerInfoEXT { + pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> { + ImportMemoryHostPointerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> { + inner: ImportMemoryHostPointerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> { + type Target = ImportMemoryHostPointerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn host_pointer(mut self, host_pointer: *mut c_void) -> Self { + self.inner.p_host_pointer = host_pointer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryHostPointerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryHostPointerPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, +} +impl ::std::default::Default for MemoryHostPointerPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryHostPointerPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT; +} +impl MemoryHostPointerPropertiesEXT { + pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> { + MemoryHostPointerPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryHostPointerPropertiesEXTBuilder<'a> { + inner: MemoryHostPointerPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> { + type Target = MemoryHostPointerPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryHostPointerPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_imported_host_pointer_alignment: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_imported_host_pointer_alignment: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalMemoryHostPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; +} +impl PhysicalDeviceExternalMemoryHostPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceExternalMemoryHostPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + #[inline] + pub fn min_imported_host_pointer_alignment( + mut self, + min_imported_host_pointer_alignment: DeviceSize, + ) -> Self { + self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub primitive_overestimation_size: f32, + pub max_extra_primitive_overestimation_size: f32, + pub extra_primitive_overestimation_size_granularity: f32, + pub primitive_underestimation: Bool32, + pub conservative_point_and_line_rasterization: Bool32, + pub degenerate_triangles_rasterized: Bool32, + pub degenerate_lines_rasterized: Bool32, + pub fully_covered_fragment_shader_input_variable: Bool32, + pub conservative_rasterization_post_depth_coverage: Bool32, +} +impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + primitive_overestimation_size: f32::default(), + max_extra_primitive_overestimation_size: f32::default(), + extra_primitive_overestimation_size_granularity: f32::default(), + primitive_underestimation: Bool32::default(), + conservative_point_and_line_rasterization: Bool32::default(), + degenerate_triangles_rasterized: Bool32::default(), + degenerate_lines_rasterized: Bool32::default(), + fully_covered_fragment_shader_input_variable: Bool32::default(), + conservative_rasterization_post_depth_coverage: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceConservativeRasterizationPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; +} +impl PhysicalDeviceConservativeRasterizationPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceConservativeRasterizationPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceConservativeRasterizationPropertiesEXT +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + #[inline] + pub fn primitive_overestimation_size(mut self, primitive_overestimation_size: f32) -> Self { + self.inner.primitive_overestimation_size = primitive_overestimation_size; + self + } + #[inline] + pub fn max_extra_primitive_overestimation_size( + mut self, + max_extra_primitive_overestimation_size: f32, + ) -> Self { + self.inner.max_extra_primitive_overestimation_size = + max_extra_primitive_overestimation_size; + self + } + #[inline] + pub fn extra_primitive_overestimation_size_granularity( + mut self, + extra_primitive_overestimation_size_granularity: f32, + ) -> Self { + self.inner.extra_primitive_overestimation_size_granularity = + extra_primitive_overestimation_size_granularity; + self + } + #[inline] + pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self { + self.inner.primitive_underestimation = primitive_underestimation.into(); + self + } + #[inline] + pub fn conservative_point_and_line_rasterization( + mut self, + conservative_point_and_line_rasterization: bool, + ) -> Self { + self.inner.conservative_point_and_line_rasterization = + conservative_point_and_line_rasterization.into(); + self + } + #[inline] + pub fn degenerate_triangles_rasterized( + mut self, + degenerate_triangles_rasterized: bool, + ) -> Self { + self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into(); + self + } + #[inline] + pub fn degenerate_lines_rasterized(mut self, degenerate_lines_rasterized: bool) -> Self { + self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into(); + self + } + #[inline] + pub fn fully_covered_fragment_shader_input_variable( + mut self, + fully_covered_fragment_shader_input_variable: bool, + ) -> Self { + self.inner.fully_covered_fragment_shader_input_variable = + fully_covered_fragment_shader_input_variable.into(); + self + } + #[inline] + pub fn conservative_rasterization_post_depth_coverage( + mut self, + conservative_rasterization_post_depth_coverage: bool, + ) -> Self { + self.inner.conservative_rasterization_post_depth_coverage = + conservative_rasterization_post_depth_coverage.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CalibratedTimestampInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub time_domain: TimeDomainEXT, +} +impl ::std::default::Default for CalibratedTimestampInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + time_domain: TimeDomainEXT::default(), + } + } +} +unsafe impl TaggedStructure for CalibratedTimestampInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::CALIBRATED_TIMESTAMP_INFO_EXT; +} +impl CalibratedTimestampInfoEXT { + pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> { + CalibratedTimestampInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CalibratedTimestampInfoEXTBuilder<'a> { + inner: CalibratedTimestampInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> { + type Target = CalibratedTimestampInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { + #[inline] + pub fn time_domain(mut self, time_domain: TimeDomainEXT) -> Self { + self.inner.time_domain = time_domain; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CalibratedTimestampInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCorePropertiesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_engine_count: u32, + pub shader_arrays_per_engine_count: u32, + pub compute_units_per_shader_array: u32, + pub simd_per_compute_unit: u32, + pub wavefronts_per_simd: u32, + pub wavefront_size: u32, + pub sgprs_per_simd: u32, + pub min_sgpr_allocation: u32, + pub max_sgpr_allocation: u32, + pub sgpr_allocation_granularity: u32, + pub vgprs_per_simd: u32, + pub min_vgpr_allocation: u32, + pub max_vgpr_allocation: u32, + pub vgpr_allocation_granularity: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_engine_count: u32::default(), + shader_arrays_per_engine_count: u32::default(), + compute_units_per_shader_array: u32::default(), + simd_per_compute_unit: u32::default(), + wavefronts_per_simd: u32::default(), + wavefront_size: u32::default(), + sgprs_per_simd: u32::default(), + min_sgpr_allocation: u32::default(), + max_sgpr_allocation: u32::default(), + sgpr_allocation_granularity: u32::default(), + vgprs_per_simd: u32::default(), + min_vgpr_allocation: u32::default(), + max_vgpr_allocation: u32::default(), + vgpr_allocation_granularity: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderCorePropertiesAMD { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; +} +impl PhysicalDeviceShaderCorePropertiesAMD { + pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + PhysicalDeviceShaderCorePropertiesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + inner: PhysicalDeviceShaderCorePropertiesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + type Target = PhysicalDeviceShaderCorePropertiesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + #[inline] + pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self { + self.inner.shader_engine_count = shader_engine_count; + self + } + #[inline] + pub fn shader_arrays_per_engine_count(mut self, shader_arrays_per_engine_count: u32) -> Self { + self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count; + self + } + #[inline] + pub fn compute_units_per_shader_array(mut self, compute_units_per_shader_array: u32) -> Self { + self.inner.compute_units_per_shader_array = compute_units_per_shader_array; + self + } + #[inline] + pub fn simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self { + self.inner.simd_per_compute_unit = simd_per_compute_unit; + self + } + #[inline] + pub fn wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self { + self.inner.wavefronts_per_simd = wavefronts_per_simd; + self + } + #[inline] + pub fn wavefront_size(mut self, wavefront_size: u32) -> Self { + self.inner.wavefront_size = wavefront_size; + self + } + #[inline] + pub fn sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self { + self.inner.sgprs_per_simd = sgprs_per_simd; + self + } + #[inline] + pub fn min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self { + self.inner.min_sgpr_allocation = min_sgpr_allocation; + self + } + #[inline] + pub fn max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self { + self.inner.max_sgpr_allocation = max_sgpr_allocation; + self + } + #[inline] + pub fn sgpr_allocation_granularity(mut self, sgpr_allocation_granularity: u32) -> Self { + self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity; + self + } + #[inline] + pub fn vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self { + self.inner.vgprs_per_simd = vgprs_per_simd; + self + } + #[inline] + pub fn min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self { + self.inner.min_vgpr_allocation = min_vgpr_allocation; + self + } + #[inline] + pub fn max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self { + self.inner.max_vgpr_allocation = max_vgpr_allocation; + self + } + #[inline] + pub fn vgpr_allocation_granularity(mut self, vgpr_allocation_granularity: u32) -> Self { + self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCoreProperties2AMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_features: ShaderCorePropertiesFlagsAMD, + pub active_compute_unit_count: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_features: ShaderCorePropertiesFlagsAMD::default(), + active_compute_unit_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderCoreProperties2AMD { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; +} +impl PhysicalDeviceShaderCoreProperties2AMD { + pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + PhysicalDeviceShaderCoreProperties2AMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + inner: PhysicalDeviceShaderCoreProperties2AMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMDBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + type Target = PhysicalDeviceShaderCoreProperties2AMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + #[inline] + pub fn shader_core_features( + mut self, + shader_core_features: ShaderCorePropertiesFlagsAMD, + ) -> Self { + self.inner.shader_core_features = shader_core_features; + self + } + #[inline] + pub fn active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self { + self.inner.active_compute_unit_count = active_compute_unit_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderCoreProperties2AMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationConservativeStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT, + pub conservative_rasterization_mode: ConservativeRasterizationModeEXT, + pub extra_primitive_overestimation_size: f32, +} +impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(), + conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(), + extra_primitive_overestimation_size: f32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationConservativeStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; +} +impl PipelineRasterizationConservativeStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationConservativeStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationConservativeStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationConservativeStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationConservativeStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn conservative_rasterization_mode( + mut self, + conservative_rasterization_mode: ConservativeRasterizationModeEXT, + ) -> Self { + self.inner.conservative_rasterization_mode = conservative_rasterization_mode; + self + } + #[inline] + pub fn extra_primitive_overestimation_size( + mut self, + extra_primitive_overestimation_size: f32, + ) -> Self { + self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorIndexingFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_input_attachment_array_dynamic_indexing: Bool32, + pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_uniform_buffer_array_non_uniform_indexing: Bool32, + pub shader_sampled_image_array_non_uniform_indexing: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_image_array_non_uniform_indexing: Bool32, + pub shader_input_attachment_array_non_uniform_indexing: Bool32, + pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32, + pub descriptor_binding_uniform_buffer_update_after_bind: Bool32, + pub descriptor_binding_sampled_image_update_after_bind: Bool32, + pub descriptor_binding_storage_image_update_after_bind: Bool32, + pub descriptor_binding_storage_buffer_update_after_bind: Bool32, + pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_update_unused_while_pending: Bool32, + pub descriptor_binding_partially_bound: Bool32, + pub descriptor_binding_variable_descriptor_count: Bool32, + pub runtime_descriptor_array: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_input_attachment_array_dynamic_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_image_array_non_uniform_indexing: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(), + descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(), + descriptor_binding_sampled_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_buffer_update_after_bind: Bool32::default(), + descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_update_unused_while_pending: Bool32::default(), + descriptor_binding_partially_bound: Bool32::default(), + descriptor_binding_variable_descriptor_count: Bool32::default(), + runtime_descriptor_array: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorIndexingFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; +} +impl PhysicalDeviceDescriptorIndexingFeatures { + pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + PhysicalDeviceDescriptorIndexingFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + inner: PhysicalDeviceDescriptorIndexingFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + type Target = PhysicalDeviceDescriptorIndexingFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + #[inline] + pub fn shader_input_attachment_array_dynamic_indexing( + mut self, + shader_input_attachment_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_input_attachment_array_dynamic_indexing = + shader_input_attachment_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_texel_buffer_array_dynamic_indexing( + mut self, + shader_uniform_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner + .shader_uniform_texel_buffer_array_dynamic_indexing = + shader_uniform_texel_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_storage_texel_buffer_array_dynamic_indexing( + mut self, + shader_storage_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner + .shader_storage_texel_buffer_array_dynamic_indexing = + shader_storage_texel_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_uniform_buffer_array_non_uniform_indexing = + shader_uniform_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_non_uniform_indexing( + mut self, + shader_sampled_image_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_sampled_image_array_non_uniform_indexing = + shader_sampled_image_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_non_uniform_indexing( + mut self, + shader_storage_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_storage_buffer_array_non_uniform_indexing = + shader_storage_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_image_array_non_uniform_indexing( + mut self, + shader_storage_image_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_storage_image_array_non_uniform_indexing = + shader_storage_image_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_non_uniform_indexing( + mut self, + shader_input_attachment_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_input_attachment_array_non_uniform_indexing = + shader_input_attachment_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_uniform_texel_buffer_array_non_uniform_indexing = + shader_uniform_texel_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_texel_buffer_array_non_uniform_indexing( + mut self, + shader_storage_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_storage_texel_buffer_array_non_uniform_indexing = + shader_storage_texel_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn descriptor_binding_uniform_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_uniform_buffer_update_after_bind = + descriptor_binding_uniform_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_sampled_image_update_after_bind( + mut self, + descriptor_binding_sampled_image_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_sampled_image_update_after_bind = + descriptor_binding_sampled_image_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_image_update_after_bind( + mut self, + descriptor_binding_storage_image_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_image_update_after_bind = + descriptor_binding_storage_image_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_buffer_update_after_bind( + mut self, + descriptor_binding_storage_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_buffer_update_after_bind = + descriptor_binding_storage_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_texel_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_uniform_texel_buffer_update_after_bind = + descriptor_binding_uniform_texel_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_texel_buffer_update_after_bind( + mut self, + descriptor_binding_storage_texel_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_texel_buffer_update_after_bind = + descriptor_binding_storage_texel_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_update_unused_while_pending( + mut self, + descriptor_binding_update_unused_while_pending: bool, + ) -> Self { + self.inner.descriptor_binding_update_unused_while_pending = + descriptor_binding_update_unused_while_pending.into(); + self + } + #[inline] + pub fn descriptor_binding_partially_bound( + mut self, + descriptor_binding_partially_bound: bool, + ) -> Self { + self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into(); + self + } + #[inline] + pub fn descriptor_binding_variable_descriptor_count( + mut self, + descriptor_binding_variable_descriptor_count: bool, + ) -> Self { + self.inner.descriptor_binding_variable_descriptor_count = + descriptor_binding_variable_descriptor_count.into(); + self + } + #[inline] + pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self { + self.inner.runtime_descriptor_array = runtime_descriptor_array.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorIndexingProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_update_after_bind_descriptors_in_all_pools: u32, + pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_sampled_image_array_non_uniform_indexing_native: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_storage_image_array_non_uniform_indexing_native: Bool32, + pub shader_input_attachment_array_non_uniform_indexing_native: Bool32, + pub robust_buffer_access_update_after_bind: Bool32, + pub quad_divergent_implicit_lod: Bool32, + pub max_per_stage_descriptor_update_after_bind_samplers: u32, + pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_sampled_images: u32, + pub max_per_stage_descriptor_update_after_bind_storage_images: u32, + pub max_per_stage_descriptor_update_after_bind_input_attachments: u32, + pub max_per_stage_update_after_bind_resources: u32, + pub max_descriptor_set_update_after_bind_samplers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_storage_buffers: u32, + pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_sampled_images: u32, + pub max_descriptor_set_update_after_bind_storage_images: u32, + pub max_descriptor_set_update_after_bind_input_attachments: u32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_update_after_bind_descriptors_in_all_pools: u32::default(), + shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_image_array_non_uniform_indexing_native: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(), + robust_buffer_access_update_after_bind: Bool32::default(), + quad_divergent_implicit_lod: Bool32::default(), + max_per_stage_descriptor_update_after_bind_samplers: u32::default(), + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_images: u32::default(), + max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(), + max_per_stage_update_after_bind_resources: u32::default(), + max_descriptor_set_update_after_bind_samplers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_sampled_images: u32::default(), + max_descriptor_set_update_after_bind_storage_images: u32::default(), + max_descriptor_set_update_after_bind_input_attachments: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorIndexingProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; +} +impl PhysicalDeviceDescriptorIndexingProperties { + pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + PhysicalDeviceDescriptorIndexingPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + inner: PhysicalDeviceDescriptorIndexingProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + type Target = PhysicalDeviceDescriptorIndexingProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + #[inline] + pub fn max_update_after_bind_descriptors_in_all_pools( + mut self, + max_update_after_bind_descriptors_in_all_pools: u32, + ) -> Self { + self.inner.max_update_after_bind_descriptors_in_all_pools = + max_update_after_bind_descriptors_in_all_pools; + self + } + #[inline] + pub fn shader_uniform_buffer_array_non_uniform_indexing_native( + mut self, + shader_uniform_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_uniform_buffer_array_non_uniform_indexing_native = + shader_uniform_buffer_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_non_uniform_indexing_native( + mut self, + shader_sampled_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_sampled_image_array_non_uniform_indexing_native = + shader_sampled_image_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_non_uniform_indexing_native( + mut self, + shader_storage_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_storage_buffer_array_non_uniform_indexing_native = + shader_storage_buffer_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_storage_image_array_non_uniform_indexing_native( + mut self, + shader_storage_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_storage_image_array_non_uniform_indexing_native = + shader_storage_image_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_non_uniform_indexing_native( + mut self, + shader_input_attachment_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_input_attachment_array_non_uniform_indexing_native = + shader_input_attachment_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn robust_buffer_access_update_after_bind( + mut self, + robust_buffer_access_update_after_bind: bool, + ) -> Self { + self.inner.robust_buffer_access_update_after_bind = + robust_buffer_access_update_after_bind.into(); + self + } + #[inline] + pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self { + self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_samplers( + mut self, + max_per_stage_descriptor_update_after_bind_samplers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_samplers = + max_per_stage_descriptor_update_after_bind_samplers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_uniform_buffers = + max_per_stage_descriptor_update_after_bind_uniform_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_buffers = + max_per_stage_descriptor_update_after_bind_storage_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_sampled_images( + mut self, + max_per_stage_descriptor_update_after_bind_sampled_images: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_sampled_images = + max_per_stage_descriptor_update_after_bind_sampled_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_storage_images( + mut self, + max_per_stage_descriptor_update_after_bind_storage_images: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_images = + max_per_stage_descriptor_update_after_bind_storage_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_input_attachments( + mut self, + max_per_stage_descriptor_update_after_bind_input_attachments: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_input_attachments = + max_per_stage_descriptor_update_after_bind_input_attachments; + self + } + #[inline] + pub fn max_per_stage_update_after_bind_resources( + mut self, + max_per_stage_update_after_bind_resources: u32, + ) -> Self { + self.inner.max_per_stage_update_after_bind_resources = + max_per_stage_update_after_bind_resources; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_samplers( + mut self, + max_descriptor_set_update_after_bind_samplers: u32, + ) -> Self { + self.inner.max_descriptor_set_update_after_bind_samplers = + max_descriptor_set_update_after_bind_samplers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_uniform_buffers( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers = + max_descriptor_set_update_after_bind_uniform_buffers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers_dynamic = + max_descriptor_set_update_after_bind_uniform_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_buffers( + mut self, + max_descriptor_set_update_after_bind_storage_buffers: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers = + max_descriptor_set_update_after_bind_storage_buffers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers_dynamic = + max_descriptor_set_update_after_bind_storage_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_sampled_images( + mut self, + max_descriptor_set_update_after_bind_sampled_images: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_sampled_images = + max_descriptor_set_update_after_bind_sampled_images; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_images( + mut self, + max_descriptor_set_update_after_bind_storage_images: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_images = + max_descriptor_set_update_after_bind_storage_images; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_input_attachments( + mut self, + max_descriptor_set_update_after_bind_input_attachments: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_input_attachments = + max_descriptor_set_update_after_bind_input_attachments; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorIndexingProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutBindingFlagsCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub binding_count: u32, + pub p_binding_flags: *const DescriptorBindingFlags, +} +impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + binding_count: u32::default(), + p_binding_flags: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetLayoutBindingFlagsCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; +} +impl DescriptorSetLayoutBindingFlagsCreateInfo { + pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + DescriptorSetLayoutBindingFlagsCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + inner: DescriptorSetLayoutBindingFlagsCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo + for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo {} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + type Target = DescriptorSetLayoutBindingFlagsCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + #[inline] + pub fn binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self { + self.inner.binding_count = binding_flags.len() as _; + self.inner.p_binding_flags = binding_flags.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetVariableDescriptorCountAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_set_count: u32, + pub p_descriptor_counts: *const u32, +} +impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + descriptor_set_count: u32::default(), + p_descriptor_counts: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetVariableDescriptorCountAllocateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; +} +impl DescriptorSetVariableDescriptorCountAllocateInfo { + pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + DescriptorSetVariableDescriptorCountAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + inner: DescriptorSetVariableDescriptorCountAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetAllocateInfo + for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo {} +impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + type Target = DescriptorSetVariableDescriptorCountAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + #[inline] + pub fn descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self { + self.inner.descriptor_set_count = descriptor_counts.len() as _; + self.inner.p_descriptor_counts = descriptor_counts.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetVariableDescriptorCountLayoutSupport { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_variable_descriptor_count: u32, +} +impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_variable_descriptor_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetVariableDescriptorCountLayoutSupport { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; +} +impl DescriptorSetVariableDescriptorCountLayoutSupport { + pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + DescriptorSetVariableDescriptorCountLayoutSupportBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + inner: DescriptorSetVariableDescriptorCountLayoutSupport, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetLayoutSupport + for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorSetLayoutSupport + for DescriptorSetVariableDescriptorCountLayoutSupport +{ +} +impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + type Target = DescriptorSetVariableDescriptorCountLayoutSupport; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + #[inline] + pub fn max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self { + self.inner.max_variable_descriptor_count = max_variable_descriptor_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentDescription2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: AttachmentDescriptionFlags, + pub format: Format, + pub samples: SampleCountFlags, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub stencil_load_op: AttachmentLoadOp, + pub stencil_store_op: AttachmentStoreOp, + pub initial_layout: ImageLayout, + pub final_layout: ImageLayout, +} +impl ::std::default::Default for AttachmentDescription2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: AttachmentDescriptionFlags::default(), + format: Format::default(), + samples: SampleCountFlags::default(), + load_op: AttachmentLoadOp::default(), + store_op: AttachmentStoreOp::default(), + stencil_load_op: AttachmentLoadOp::default(), + stencil_store_op: AttachmentStoreOp::default(), + initial_layout: ImageLayout::default(), + final_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentDescription2 { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_2; +} +impl AttachmentDescription2 { + pub fn builder<'a>() -> AttachmentDescription2Builder<'a> { + AttachmentDescription2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentDescription2Builder<'a> { + inner: AttachmentDescription2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAttachmentDescription2 {} +impl<'a> ::std::ops::Deref for AttachmentDescription2Builder<'a> { + type Target = AttachmentDescription2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentDescription2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn samples(mut self, samples: SampleCountFlags) -> Self { + self.inner.samples = samples; + self + } + #[inline] + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { + self.inner.load_op = load_op; + self + } + #[inline] + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { + self.inner.store_op = store_op; + self + } + #[inline] + pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self { + self.inner.stencil_load_op = stencil_load_op; + self + } + #[inline] + pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self { + self.inner.stencil_store_op = stencil_store_op; + self + } + #[inline] + pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { + self.inner.initial_layout = initial_layout; + self + } + #[inline] + pub fn final_layout(mut self, final_layout: ImageLayout) -> Self { + self.inner.final_layout = final_layout; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentDescription2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentReference2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment: u32, + pub layout: ImageLayout, + pub aspect_mask: ImageAspectFlags, +} +impl ::std::default::Default for AttachmentReference2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment: u32::default(), + layout: ImageLayout::default(), + aspect_mask: ImageAspectFlags::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentReference2 { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_2; +} +impl AttachmentReference2 { + pub fn builder<'a>() -> AttachmentReference2Builder<'a> { + AttachmentReference2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentReference2Builder<'a> { + inner: AttachmentReference2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAttachmentReference2 {} +impl<'a> ::std::ops::Deref for AttachmentReference2Builder<'a> { + type Target = AttachmentReference2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentReference2Builder<'a> { + #[inline] + pub fn attachment(mut self, attachment: u32) -> Self { + self.inner.attachment = attachment; + self + } + #[inline] + pub fn layout(mut self, layout: ImageLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentReference2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassDescription2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SubpassDescriptionFlags, + pub pipeline_bind_point: PipelineBindPoint, + pub view_mask: u32, + pub input_attachment_count: u32, + pub p_input_attachments: *const AttachmentReference2, + pub color_attachment_count: u32, + pub p_color_attachments: *const AttachmentReference2, + pub p_resolve_attachments: *const AttachmentReference2, + pub p_depth_stencil_attachment: *const AttachmentReference2, + pub preserve_attachment_count: u32, + pub p_preserve_attachments: *const u32, +} +impl ::std::default::Default for SubpassDescription2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SubpassDescriptionFlags::default(), + pipeline_bind_point: PipelineBindPoint::default(), + view_mask: u32::default(), + input_attachment_count: u32::default(), + p_input_attachments: ::std::ptr::null(), + color_attachment_count: u32::default(), + p_color_attachments: ::std::ptr::null(), + p_resolve_attachments: ::std::ptr::null(), + p_depth_stencil_attachment: ::std::ptr::null(), + preserve_attachment_count: u32::default(), + p_preserve_attachments: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubpassDescription2 { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_2; +} +impl SubpassDescription2 { + pub fn builder<'a>() -> SubpassDescription2Builder<'a> { + SubpassDescription2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDescription2Builder<'a> { + inner: SubpassDescription2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubpassDescription2 {} +impl<'a> ::std::ops::Deref for SubpassDescription2Builder<'a> { + type Target = SubpassDescription2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDescription2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + #[inline] + pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference2]) -> Self { + self.inner.input_attachment_count = input_attachments.len() as _; + self.inner.p_input_attachments = input_attachments.as_ptr(); + self + } + #[inline] + pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference2]) -> Self { + self.inner.color_attachment_count = color_attachments.len() as _; + self.inner.p_color_attachments = color_attachments.as_ptr(); + self + } + #[inline] + pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference2]) -> Self { + self.inner.color_attachment_count = resolve_attachments.len() as _; + self.inner.p_resolve_attachments = resolve_attachments.as_ptr(); + self + } + #[inline] + pub fn depth_stencil_attachment( + mut self, + depth_stencil_attachment: &'a AttachmentReference2, + ) -> Self { + self.inner.p_depth_stencil_attachment = depth_stencil_attachment; + self + } + #[inline] + pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self { + self.inner.preserve_attachment_count = preserve_attachments.len() as _; + self.inner.p_preserve_attachments = preserve_attachments.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDescription2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassDependency2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subpass: u32, + pub dst_subpass: u32, + pub src_stage_mask: PipelineStageFlags, + pub dst_stage_mask: PipelineStageFlags, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub dependency_flags: DependencyFlags, + pub view_offset: i32, +} +impl ::std::default::Default for SubpassDependency2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_subpass: u32::default(), + dst_subpass: u32::default(), + src_stage_mask: PipelineStageFlags::default(), + dst_stage_mask: PipelineStageFlags::default(), + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + dependency_flags: DependencyFlags::default(), + view_offset: i32::default(), + } + } +} +unsafe impl TaggedStructure for SubpassDependency2 { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DEPENDENCY_2; +} +impl SubpassDependency2 { + pub fn builder<'a>() -> SubpassDependency2Builder<'a> { + SubpassDependency2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDependency2Builder<'a> { + inner: SubpassDependency2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubpassDependency2 {} +impl<'a> ::std::ops::Deref for SubpassDependency2Builder<'a> { + type Target = SubpassDependency2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDependency2Builder<'a> { + #[inline] + pub fn src_subpass(mut self, src_subpass: u32) -> Self { + self.inner.src_subpass = src_subpass; + self + } + #[inline] + pub fn dst_subpass(mut self, dst_subpass: u32) -> Self { + self.inner.dst_subpass = dst_subpass; + self + } + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { + self.inner.dependency_flags = dependency_flags; + self + } + #[inline] + pub fn view_offset(mut self, view_offset: i32) -> Self { + self.inner.view_offset = view_offset; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDependency2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreateInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderPassCreateFlags, + pub attachment_count: u32, + pub p_attachments: *const AttachmentDescription2, + pub subpass_count: u32, + pub p_subpasses: *const SubpassDescription2, + pub dependency_count: u32, + pub p_dependencies: *const SubpassDependency2, + pub correlated_view_mask_count: u32, + pub p_correlated_view_masks: *const u32, +} +impl ::std::default::Default for RenderPassCreateInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderPassCreateFlags::default(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + subpass_count: u32::default(), + p_subpasses: ::std::ptr::null(), + dependency_count: u32::default(), + p_dependencies: ::std::ptr::null(), + correlated_view_mask_count: u32::default(), + p_correlated_view_masks: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassCreateInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO_2; +} +impl RenderPassCreateInfo2 { + pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> { + RenderPassCreateInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreateInfo2Builder<'a> { + inner: RenderPassCreateInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderPassCreateInfo2 {} +impl<'a> ::std::ops::Deref for RenderPassCreateInfo2Builder<'a> { + type Target = RenderPassCreateInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreateInfo2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn attachments(mut self, attachments: &'a [AttachmentDescription2]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[inline] + pub fn subpasses(mut self, subpasses: &'a [SubpassDescription2]) -> Self { + self.inner.subpass_count = subpasses.len() as _; + self.inner.p_subpasses = subpasses.as_ptr(); + self + } + #[inline] + pub fn dependencies(mut self, dependencies: &'a [SubpassDependency2]) -> Self { + self.inner.dependency_count = dependencies.len() as _; + self.inner.p_dependencies = dependencies.as_ptr(); + self + } + #[inline] + pub fn correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self { + self.inner.correlated_view_mask_count = correlated_view_masks.len() as _; + self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreateInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub contents: SubpassContents, +} +impl ::std::default::Default for SubpassBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + contents: SubpassContents::default(), + } + } +} +unsafe impl TaggedStructure for SubpassBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_BEGIN_INFO; +} +impl SubpassBeginInfo { + pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> { + SubpassBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassBeginInfoBuilder<'a> { + inner: SubpassBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> { + type Target = SubpassBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassBeginInfoBuilder<'a> { + #[inline] + pub fn contents(mut self, contents: SubpassContents) -> Self { + self.inner.contents = contents; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassBeginInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassEndInfo { + pub s_type: StructureType, + pub p_next: *const c_void, +} +impl ::std::default::Default for SubpassEndInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubpassEndInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_END_INFO; +} +impl SubpassEndInfo { + pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> { + SubpassEndInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassEndInfoBuilder<'a> { + inner: SubpassEndInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubpassEndInfo {} +impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> { + type Target = SubpassEndInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassEndInfoBuilder<'a> { + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassEndInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTimelineSemaphoreFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub timeline_semaphore: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + timeline_semaphore: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTimelineSemaphoreFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; +} +impl PhysicalDeviceTimelineSemaphoreFeatures { + pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + PhysicalDeviceTimelineSemaphoreFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + inner: PhysicalDeviceTimelineSemaphoreFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + type Target = PhysicalDeviceTimelineSemaphoreFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + #[inline] + pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self { + self.inner.timeline_semaphore = timeline_semaphore.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTimelineSemaphoreFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTimelineSemaphoreProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_timeline_semaphore_value_difference: u64, +} +impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_timeline_semaphore_value_difference: u64::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTimelineSemaphoreProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; +} +impl PhysicalDeviceTimelineSemaphoreProperties { + pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + PhysicalDeviceTimelineSemaphorePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + inner: PhysicalDeviceTimelineSemaphoreProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + type Target = PhysicalDeviceTimelineSemaphoreProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + #[inline] + pub fn max_timeline_semaphore_value_difference( + mut self, + max_timeline_semaphore_value_difference: u64, + ) -> Self { + self.inner.max_timeline_semaphore_value_difference = + max_timeline_semaphore_value_difference; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTimelineSemaphoreProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreTypeCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore_type: SemaphoreType, + pub initial_value: u64, +} +impl ::std::default::Default for SemaphoreTypeCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore_type: SemaphoreType::default(), + initial_value: u64::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreTypeCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_TYPE_CREATE_INFO; +} +impl SemaphoreTypeCreateInfo { + pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> { + SemaphoreTypeCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreTypeCreateInfoBuilder<'a> { + inner: SemaphoreTypeCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfoBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo {} +unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfoBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo {} +impl<'a> ::std::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> { + type Target = SemaphoreTypeCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreTypeCreateInfoBuilder<'a> { + #[inline] + pub fn semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self { + self.inner.semaphore_type = semaphore_type; + self + } + #[inline] + pub fn initial_value(mut self, initial_value: u64) -> Self { + self.inner.initial_value = initial_value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreTypeCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct TimelineSemaphoreSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_value_count: u32, + pub p_wait_semaphore_values: *const u64, + pub signal_semaphore_value_count: u32, + pub p_signal_semaphore_values: *const u64, +} +impl ::std::default::Default for TimelineSemaphoreSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_value_count: u32::default(), + p_wait_semaphore_values: ::std::ptr::null(), + signal_semaphore_value_count: u32::default(), + p_signal_semaphore_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for TimelineSemaphoreSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO; +} +impl TimelineSemaphoreSubmitInfo { + pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> { + TimelineSemaphoreSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TimelineSemaphoreSubmitInfoBuilder<'a> { + inner: TimelineSemaphoreSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo {} +unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {} +unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo {} +impl<'a> ::std::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> { + type Target = TimelineSemaphoreSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> { + #[inline] + pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self { + self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _; + self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); + self + } + #[inline] + pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self { + self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _; + self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TimelineSemaphoreSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreWaitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SemaphoreWaitFlags, + pub semaphore_count: u32, + pub p_semaphores: *const Semaphore, + pub p_values: *const u64, +} +impl ::std::default::Default for SemaphoreWaitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SemaphoreWaitFlags::default(), + semaphore_count: u32::default(), + p_semaphores: ::std::ptr::null(), + p_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SemaphoreWaitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_WAIT_INFO; +} +impl SemaphoreWaitInfo { + pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> { + SemaphoreWaitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreWaitInfoBuilder<'a> { + inner: SemaphoreWaitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> { + type Target = SemaphoreWaitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreWaitInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SemaphoreWaitFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> Self { + self.inner.semaphore_count = semaphores.len() as _; + self.inner.p_semaphores = semaphores.as_ptr(); + self + } + #[inline] + pub fn values(mut self, values: &'a [u64]) -> Self { + self.inner.semaphore_count = values.len() as _; + self.inner.p_values = values.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreWaitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreSignalInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub value: u64, +} +impl ::std::default::Default for SemaphoreSignalInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + value: u64::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreSignalInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SIGNAL_INFO; +} +impl SemaphoreSignalInfo { + pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> { + SemaphoreSignalInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreSignalInfoBuilder<'a> { + inner: SemaphoreSignalInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> { + type Target = SemaphoreSignalInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreSignalInfoBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn value(mut self, value: u64) -> Self { + self.inner.value = value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreSignalInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VertexInputBindingDivisorDescriptionEXT { + pub binding: u32, + pub divisor: u32, +} +impl VertexInputBindingDivisorDescriptionEXT { + pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + VertexInputBindingDivisorDescriptionEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + inner: VertexInputBindingDivisorDescriptionEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + type Target = VertexInputBindingDivisorDescriptionEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn divisor(mut self, divisor: u32) -> Self { + self.inner.divisor = divisor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineVertexInputDivisorStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_binding_divisor_count: u32, + pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT, +} +impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_binding_divisor_count: u32::default(), + p_vertex_binding_divisors: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineVertexInputDivisorStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT; +} +impl PipelineVertexInputDivisorStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + PipelineVertexInputDivisorStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + inner: PipelineVertexInputDivisorStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineVertexInputStateCreateInfo + for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineVertexInputStateCreateInfo + for PipelineVertexInputDivisorStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + type Target = PipelineVertexInputDivisorStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn vertex_binding_divisors( + mut self, + vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT], + ) -> Self { + self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as _; + self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_vertex_attrib_divisor: u32, +} +impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_vertex_attrib_divisor: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; +} +impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self { + self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePCIBusInfoPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pci_domain: u32, + pub pci_bus: u32, + pub pci_device: u32, + pub pci_function: u32, +} +impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pci_domain: u32::default(), + pci_bus: u32::default(), + pci_device: u32::default(), + pci_function: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePCIBusInfoPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; +} +impl PhysicalDevicePCIBusInfoPropertiesEXT { + pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + PhysicalDevicePCIBusInfoPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + inner: PhysicalDevicePCIBusInfoPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + type Target = PhysicalDevicePCIBusInfoPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + #[inline] + pub fn pci_domain(mut self, pci_domain: u32) -> Self { + self.inner.pci_domain = pci_domain; + self + } + #[inline] + pub fn pci_bus(mut self, pci_bus: u32) -> Self { + self.inner.pci_bus = pci_bus; + self + } + #[inline] + pub fn pci_device(mut self, pci_device: u32) -> Self { + self.inner.pci_device = pci_device; + self + } + #[inline] + pub fn pci_function(mut self, pci_function: u32) -> Self { + self.inner.pci_function = pci_function; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportAndroidHardwareBufferInfoANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: *mut AHardwareBuffer, +} +impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ImportAndroidHardwareBufferInfoANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; +} +impl ImportAndroidHardwareBufferInfoANDROID { + pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + ImportAndroidHardwareBufferInfoANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + inner: ImportAndroidHardwareBufferInfoANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {} +impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + type Target = ImportAndroidHardwareBufferInfoANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: *mut AHardwareBuffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferUsageANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub android_hardware_buffer_usage: u64, +} +impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + android_hardware_buffer_usage: u64::default(), + } + } +} +unsafe impl TaggedStructure for AndroidHardwareBufferUsageANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; +} +impl AndroidHardwareBufferUsageANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> { + AndroidHardwareBufferUsageANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> { + inner: AndroidHardwareBufferUsageANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferUsageANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> { + #[inline] + pub fn android_hardware_buffer_usage(mut self, android_hardware_buffer_usage: u64) -> Self { + self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidHardwareBufferUsageANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferPropertiesANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub allocation_size: DeviceSize, + pub memory_type_bits: u32, +} +impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + allocation_size: DeviceSize::default(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for AndroidHardwareBufferPropertiesANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; +} +impl AndroidHardwareBufferPropertiesANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + AndroidHardwareBufferPropertiesANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + inner: AndroidHardwareBufferPropertiesANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferPropertiesANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + #[inline] + pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self { + self.inner.allocation_size = allocation_size; + self + } + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetAndroidHardwareBufferInfoANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, +} +impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetAndroidHardwareBufferInfoANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; +} +impl MemoryGetAndroidHardwareBufferInfoANDROID { + pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + MemoryGetAndroidHardwareBufferInfoANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + inner: MemoryGetAndroidHardwareBufferInfoANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + type Target = MemoryGetAndroidHardwareBufferInfoANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferFormatPropertiesANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub external_format: u64, + pub format_features: FormatFeatureFlags, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, +} +impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + external_format: u64::default(), + format_features: FormatFeatureFlags::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + } + } +} +unsafe impl TaggedStructure for AndroidHardwareBufferFormatPropertiesANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; +} +impl AndroidHardwareBufferFormatPropertiesANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + AndroidHardwareBufferFormatPropertiesANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + inner: AndroidHardwareBufferFormatPropertiesANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_> +{ +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatPropertiesANDROID +{ +} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferFormatPropertiesANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.inner.external_format = external_format; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { + self.inner.format_features = format_features; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceConditionalRenderingInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub conditional_rendering_enable: Bool32, +} +impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + conditional_rendering_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceConditionalRenderingInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; +} +impl CommandBufferInheritanceConditionalRenderingInfoEXT { + pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + CommandBufferInheritanceConditionalRenderingInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + inner: CommandBufferInheritanceConditionalRenderingInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceConditionalRenderingInfoEXT +{ +} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + type Target = CommandBufferInheritanceConditionalRenderingInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + #[inline] + pub fn conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self { + self.inner.conditional_rendering_enable = conditional_rendering_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalFormatANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_format: u64, +} +impl ::std::default::Default for ExternalFormatANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_format: u64::default(), + } + } +} +unsafe impl TaggedStructure for ExternalFormatANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FORMAT_ANDROID; +} +impl ExternalFormatANDROID { + pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> { + ExternalFormatANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalFormatANDROIDBuilder<'a> { + inner: ExternalFormatANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {} +impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> { + type Target = ExternalFormatANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalFormatANDROIDBuilder<'a> { + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.inner.external_format = external_format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalFormatANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevice8BitStorageFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub storage_buffer8_bit_access: Bool32, + pub uniform_and_storage_buffer8_bit_access: Bool32, + pub storage_push_constant8: Bool32, +} +impl ::std::default::Default for PhysicalDevice8BitStorageFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + storage_buffer8_bit_access: Bool32::default(), + uniform_and_storage_buffer8_bit_access: Bool32::default(), + storage_push_constant8: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevice8BitStorageFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; +} +impl PhysicalDevice8BitStorageFeatures { + pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> { + PhysicalDevice8BitStorageFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> { + inner: PhysicalDevice8BitStorageFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> { + type Target = PhysicalDevice8BitStorageFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> { + #[inline] + pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self { + self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); + self + } + #[inline] + pub fn uniform_and_storage_buffer8_bit_access( + mut self, + uniform_and_storage_buffer8_bit_access: bool, + ) -> Self { + self.inner.uniform_and_storage_buffer8_bit_access = + uniform_and_storage_buffer8_bit_access.into(); + self + } + #[inline] + pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self { + self.inner.storage_push_constant8 = storage_push_constant8.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevice8BitStorageFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceConditionalRenderingFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub conditional_rendering: Bool32, + pub inherited_conditional_rendering: Bool32, +} +impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + conditional_rendering: Bool32::default(), + inherited_conditional_rendering: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceConditionalRenderingFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; +} +impl PhysicalDeviceConditionalRenderingFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + PhysicalDeviceConditionalRenderingFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceConditionalRenderingFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceConditionalRenderingFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + #[inline] + pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self { + self.inner.conditional_rendering = conditional_rendering.into(); + self + } + #[inline] + pub fn inherited_conditional_rendering( + mut self, + inherited_conditional_rendering: bool, + ) -> Self { + self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkanMemoryModelFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub vulkan_memory_model: Bool32, + pub vulkan_memory_model_device_scope: Bool32, + pub vulkan_memory_model_availability_visibility_chains: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + vulkan_memory_model: Bool32::default(), + vulkan_memory_model_device_scope: Bool32::default(), + vulkan_memory_model_availability_visibility_chains: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkanMemoryModelFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; +} +impl PhysicalDeviceVulkanMemoryModelFeatures { + pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + PhysicalDeviceVulkanMemoryModelFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + inner: PhysicalDeviceVulkanMemoryModelFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + type Target = PhysicalDeviceVulkanMemoryModelFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + #[inline] + pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self { + self.inner.vulkan_memory_model = vulkan_memory_model.into(); + self + } + #[inline] + pub fn vulkan_memory_model_device_scope( + mut self, + vulkan_memory_model_device_scope: bool, + ) -> Self { + self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); + self + } + #[inline] + pub fn vulkan_memory_model_availability_visibility_chains( + mut self, + vulkan_memory_model_availability_visibility_chains: bool, + ) -> Self { + self.inner + .vulkan_memory_model_availability_visibility_chains = + vulkan_memory_model_availability_visibility_chains.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderAtomicInt64Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_buffer_int64_atomics: Bool32, + pub shader_shared_int64_atomics: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_buffer_int64_atomics: Bool32::default(), + shader_shared_int64_atomics: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicInt64Features { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; +} +impl PhysicalDeviceShaderAtomicInt64Features { + pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + PhysicalDeviceShaderAtomicInt64FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + inner: PhysicalDeviceShaderAtomicInt64Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderAtomicInt64Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + #[inline] + pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self { + self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); + self + } + #[inline] + pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self { + self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderAtomicInt64Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_buffer_float32_atomics: Bool32, + pub shader_buffer_float32_atomic_add: Bool32, + pub shader_buffer_float64_atomics: Bool32, + pub shader_buffer_float64_atomic_add: Bool32, + pub shader_shared_float32_atomics: Bool32, + pub shader_shared_float32_atomic_add: Bool32, + pub shader_shared_float64_atomics: Bool32, + pub shader_shared_float64_atomic_add: Bool32, + pub shader_image_float32_atomics: Bool32, + pub shader_image_float32_atomic_add: Bool32, + pub sparse_image_float32_atomics: Bool32, + pub sparse_image_float32_atomic_add: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_buffer_float32_atomics: Bool32::default(), + shader_buffer_float32_atomic_add: Bool32::default(), + shader_buffer_float64_atomics: Bool32::default(), + shader_buffer_float64_atomic_add: Bool32::default(), + shader_shared_float32_atomics: Bool32::default(), + shader_shared_float32_atomic_add: Bool32::default(), + shader_shared_float64_atomics: Bool32::default(), + shader_shared_float64_atomic_add: Bool32::default(), + shader_image_float32_atomics: Bool32::default(), + shader_image_float32_atomic_add: Bool32::default(), + sparse_image_float32_atomics: Bool32::default(), + sparse_image_float32_atomic_add: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicFloatFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; +} +impl PhysicalDeviceShaderAtomicFloatFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_buffer_float32_atomics(mut self, shader_buffer_float32_atomics: bool) -> Self { + self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into(); + self + } + #[inline] + pub fn shader_buffer_float32_atomic_add( + mut self, + shader_buffer_float32_atomic_add: bool, + ) -> Self { + self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into(); + self + } + #[inline] + pub fn shader_buffer_float64_atomics(mut self, shader_buffer_float64_atomics: bool) -> Self { + self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into(); + self + } + #[inline] + pub fn shader_buffer_float64_atomic_add( + mut self, + shader_buffer_float64_atomic_add: bool, + ) -> Self { + self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into(); + self + } + #[inline] + pub fn shader_shared_float32_atomics(mut self, shader_shared_float32_atomics: bool) -> Self { + self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into(); + self + } + #[inline] + pub fn shader_shared_float32_atomic_add( + mut self, + shader_shared_float32_atomic_add: bool, + ) -> Self { + self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into(); + self + } + #[inline] + pub fn shader_shared_float64_atomics(mut self, shader_shared_float64_atomics: bool) -> Self { + self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into(); + self + } + #[inline] + pub fn shader_shared_float64_atomic_add( + mut self, + shader_shared_float64_atomic_add: bool, + ) -> Self { + self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into(); + self + } + #[inline] + pub fn shader_image_float32_atomics(mut self, shader_image_float32_atomics: bool) -> Self { + self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into(); + self + } + #[inline] + pub fn shader_image_float32_atomic_add( + mut self, + shader_image_float32_atomic_add: bool, + ) -> Self { + self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into(); + self + } + #[inline] + pub fn sparse_image_float32_atomics(mut self, sparse_image_float32_atomics: bool) -> Self { + self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into(); + self + } + #[inline] + pub fn sparse_image_float32_atomic_add( + mut self, + sparse_image_float32_atomic_add: bool, + ) -> Self { + self.inner.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_buffer_float16_atomics: Bool32, + pub shader_buffer_float16_atomic_add: Bool32, + pub shader_buffer_float16_atomic_min_max: Bool32, + pub shader_buffer_float32_atomic_min_max: Bool32, + pub shader_buffer_float64_atomic_min_max: Bool32, + pub shader_shared_float16_atomics: Bool32, + pub shader_shared_float16_atomic_add: Bool32, + pub shader_shared_float16_atomic_min_max: Bool32, + pub shader_shared_float32_atomic_min_max: Bool32, + pub shader_shared_float64_atomic_min_max: Bool32, + pub shader_image_float32_atomic_min_max: Bool32, + pub sparse_image_float32_atomic_min_max: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_buffer_float16_atomics: Bool32::default(), + shader_buffer_float16_atomic_add: Bool32::default(), + shader_buffer_float16_atomic_min_max: Bool32::default(), + shader_buffer_float32_atomic_min_max: Bool32::default(), + shader_buffer_float64_atomic_min_max: Bool32::default(), + shader_shared_float16_atomics: Bool32::default(), + shader_shared_float16_atomic_add: Bool32::default(), + shader_shared_float16_atomic_min_max: Bool32::default(), + shader_shared_float32_atomic_min_max: Bool32::default(), + shader_shared_float64_atomic_min_max: Bool32::default(), + shader_image_float32_atomic_min_max: Bool32::default(), + sparse_image_float32_atomic_min_max: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; +} +impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self { + self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into(); + self + } + #[inline] + pub fn shader_buffer_float16_atomic_add( + mut self, + shader_buffer_float16_atomic_add: bool, + ) -> Self { + self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into(); + self + } + #[inline] + pub fn shader_buffer_float16_atomic_min_max( + mut self, + shader_buffer_float16_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float16_atomic_min_max = + shader_buffer_float16_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_buffer_float32_atomic_min_max( + mut self, + shader_buffer_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float32_atomic_min_max = + shader_buffer_float32_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_buffer_float64_atomic_min_max( + mut self, + shader_buffer_float64_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float64_atomic_min_max = + shader_buffer_float64_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self { + self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into(); + self + } + #[inline] + pub fn shader_shared_float16_atomic_add( + mut self, + shader_shared_float16_atomic_add: bool, + ) -> Self { + self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into(); + self + } + #[inline] + pub fn shader_shared_float16_atomic_min_max( + mut self, + shader_shared_float16_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float16_atomic_min_max = + shader_shared_float16_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_shared_float32_atomic_min_max( + mut self, + shader_shared_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float32_atomic_min_max = + shader_shared_float32_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_shared_float64_atomic_min_max( + mut self, + shader_shared_float64_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float64_atomic_min_max = + shader_shared_float64_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_image_float32_atomic_min_max( + mut self, + shader_image_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into(); + self + } + #[inline] + pub fn sparse_image_float32_atomic_min_max( + mut self, + sparse_image_float32_atomic_min_max: bool, + ) -> Self { + self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub vertex_attribute_instance_rate_divisor: Bool32, + pub vertex_attribute_instance_rate_zero_divisor: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + vertex_attribute_instance_rate_divisor: Bool32::default(), + vertex_attribute_instance_rate_zero_divisor: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT; +} +impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + #[inline] + pub fn vertex_attribute_instance_rate_divisor( + mut self, + vertex_attribute_instance_rate_divisor: bool, + ) -> Self { + self.inner.vertex_attribute_instance_rate_divisor = + vertex_attribute_instance_rate_divisor.into(); + self + } + #[inline] + pub fn vertex_attribute_instance_rate_zero_divisor( + mut self, + vertex_attribute_instance_rate_zero_divisor: bool, + ) -> Self { + self.inner.vertex_attribute_instance_rate_zero_divisor = + vertex_attribute_instance_rate_zero_divisor.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyCheckpointPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub checkpoint_execution_stage_mask: PipelineStageFlags, +} +impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + checkpoint_execution_stage_mask: PipelineStageFlags::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyCheckpointPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; +} +impl QueueFamilyCheckpointPropertiesNV { + pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> { + QueueFamilyCheckpointPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> { + inner: QueueFamilyCheckpointPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {} +impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> { + type Target = QueueFamilyCheckpointPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> { + #[inline] + pub fn checkpoint_execution_stage_mask( + mut self, + checkpoint_execution_stage_mask: PipelineStageFlags, + ) -> Self { + self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyCheckpointPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CheckpointDataNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stage: PipelineStageFlags, + pub p_checkpoint_marker: *mut c_void, +} +impl ::std::default::Default for CheckpointDataNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stage: PipelineStageFlags::default(), + p_checkpoint_marker: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for CheckpointDataNV { + const STRUCTURE_TYPE: StructureType = StructureType::CHECKPOINT_DATA_NV; +} +impl CheckpointDataNV { + pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> { + CheckpointDataNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CheckpointDataNVBuilder<'a> { + inner: CheckpointDataNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> { + type Target = CheckpointDataNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CheckpointDataNVBuilder<'a> { + #[inline] + pub fn stage(mut self, stage: PipelineStageFlags) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self { + self.inner.p_checkpoint_marker = checkpoint_marker; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CheckpointDataNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthStencilResolveProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_depth_resolve_modes: ResolveModeFlags, + pub supported_stencil_resolve_modes: ResolveModeFlags, + pub independent_resolve_none: Bool32, + pub independent_resolve: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_depth_resolve_modes: ResolveModeFlags::default(), + supported_stencil_resolve_modes: ResolveModeFlags::default(), + independent_resolve_none: Bool32::default(), + independent_resolve: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDepthStencilResolveProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; +} +impl PhysicalDeviceDepthStencilResolveProperties { + pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + PhysicalDeviceDepthStencilResolvePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + inner: PhysicalDeviceDepthStencilResolveProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + type Target = PhysicalDeviceDepthStencilResolveProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + #[inline] + pub fn supported_depth_resolve_modes( + mut self, + supported_depth_resolve_modes: ResolveModeFlags, + ) -> Self { + self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; + self + } + #[inline] + pub fn supported_stencil_resolve_modes( + mut self, + supported_stencil_resolve_modes: ResolveModeFlags, + ) -> Self { + self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self + } + #[inline] + pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self { + self.inner.independent_resolve_none = independent_resolve_none.into(); + self + } + #[inline] + pub fn independent_resolve(mut self, independent_resolve: bool) -> Self { + self.inner.independent_resolve = independent_resolve.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDepthStencilResolveProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassDescriptionDepthStencilResolve { + pub s_type: StructureType, + pub p_next: *const c_void, + pub depth_resolve_mode: ResolveModeFlags, + pub stencil_resolve_mode: ResolveModeFlags, + pub p_depth_stencil_resolve_attachment: *const AttachmentReference2, +} +impl ::std::default::Default for SubpassDescriptionDepthStencilResolve { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + depth_resolve_mode: ResolveModeFlags::default(), + stencil_resolve_mode: ResolveModeFlags::default(), + p_depth_stencil_resolve_attachment: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubpassDescriptionDepthStencilResolve { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; +} +impl SubpassDescriptionDepthStencilResolve { + pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> { + SubpassDescriptionDepthStencilResolveBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> { + inner: SubpassDescriptionDepthStencilResolve, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolveBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve {} +impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> { + type Target = SubpassDescriptionDepthStencilResolve; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> { + #[inline] + pub fn depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlags) -> Self { + self.inner.depth_resolve_mode = depth_resolve_mode; + self + } + #[inline] + pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlags) -> Self { + self.inner.stencil_resolve_mode = stencil_resolve_mode; + self + } + #[inline] + pub fn depth_stencil_resolve_attachment( + mut self, + depth_stencil_resolve_attachment: &'a AttachmentReference2, + ) -> Self { + self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDescriptionDepthStencilResolve { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewASTCDecodeModeEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub decode_mode: Format, +} +impl ::std::default::Default for ImageViewASTCDecodeModeEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + decode_mode: Format::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewASTCDecodeModeEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT; +} +impl ImageViewASTCDecodeModeEXT { + pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> { + ImageViewASTCDecodeModeEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewASTCDecodeModeEXTBuilder<'a> { + inner: ImageViewASTCDecodeModeEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {} +impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> { + type Target = ImageViewASTCDecodeModeEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> { + #[inline] + pub fn decode_mode(mut self, decode_mode: Format) -> Self { + self.inner.decode_mode = decode_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewASTCDecodeModeEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceASTCDecodeFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub decode_mode_shared_exponent: Bool32, +} +impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + decode_mode_shared_exponent: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceASTCDecodeFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; +} +impl PhysicalDeviceASTCDecodeFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + PhysicalDeviceASTCDecodeFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceASTCDecodeFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceASTCDecodeFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + #[inline] + pub fn decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self { + self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTransformFeedbackFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub transform_feedback: Bool32, + pub geometry_streams: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + transform_feedback: Bool32::default(), + geometry_streams: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTransformFeedbackFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; +} +impl PhysicalDeviceTransformFeedbackFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + PhysicalDeviceTransformFeedbackFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceTransformFeedbackFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceTransformFeedbackFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + #[inline] + pub fn transform_feedback(mut self, transform_feedback: bool) -> Self { + self.inner.transform_feedback = transform_feedback.into(); + self + } + #[inline] + pub fn geometry_streams(mut self, geometry_streams: bool) -> Self { + self.inner.geometry_streams = geometry_streams.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTransformFeedbackPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_transform_feedback_streams: u32, + pub max_transform_feedback_buffers: u32, + pub max_transform_feedback_buffer_size: DeviceSize, + pub max_transform_feedback_stream_data_size: u32, + pub max_transform_feedback_buffer_data_size: u32, + pub max_transform_feedback_buffer_data_stride: u32, + pub transform_feedback_queries: Bool32, + pub transform_feedback_streams_lines_triangles: Bool32, + pub transform_feedback_rasterization_stream_select: Bool32, + pub transform_feedback_draw: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_transform_feedback_streams: u32::default(), + max_transform_feedback_buffers: u32::default(), + max_transform_feedback_buffer_size: DeviceSize::default(), + max_transform_feedback_stream_data_size: u32::default(), + max_transform_feedback_buffer_data_size: u32::default(), + max_transform_feedback_buffer_data_stride: u32::default(), + transform_feedback_queries: Bool32::default(), + transform_feedback_streams_lines_triangles: Bool32::default(), + transform_feedback_rasterization_stream_select: Bool32::default(), + transform_feedback_draw: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTransformFeedbackPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; +} +impl PhysicalDeviceTransformFeedbackPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + PhysicalDeviceTransformFeedbackPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceTransformFeedbackPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceTransformFeedbackPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_transform_feedback_streams(mut self, max_transform_feedback_streams: u32) -> Self { + self.inner.max_transform_feedback_streams = max_transform_feedback_streams; + self + } + #[inline] + pub fn max_transform_feedback_buffers(mut self, max_transform_feedback_buffers: u32) -> Self { + self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers; + self + } + #[inline] + pub fn max_transform_feedback_buffer_size( + mut self, + max_transform_feedback_buffer_size: DeviceSize, + ) -> Self { + self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size; + self + } + #[inline] + pub fn max_transform_feedback_stream_data_size( + mut self, + max_transform_feedback_stream_data_size: u32, + ) -> Self { + self.inner.max_transform_feedback_stream_data_size = + max_transform_feedback_stream_data_size; + self + } + #[inline] + pub fn max_transform_feedback_buffer_data_size( + mut self, + max_transform_feedback_buffer_data_size: u32, + ) -> Self { + self.inner.max_transform_feedback_buffer_data_size = + max_transform_feedback_buffer_data_size; + self + } + #[inline] + pub fn max_transform_feedback_buffer_data_stride( + mut self, + max_transform_feedback_buffer_data_stride: u32, + ) -> Self { + self.inner.max_transform_feedback_buffer_data_stride = + max_transform_feedback_buffer_data_stride; + self + } + #[inline] + pub fn transform_feedback_queries(mut self, transform_feedback_queries: bool) -> Self { + self.inner.transform_feedback_queries = transform_feedback_queries.into(); + self + } + #[inline] + pub fn transform_feedback_streams_lines_triangles( + mut self, + transform_feedback_streams_lines_triangles: bool, + ) -> Self { + self.inner.transform_feedback_streams_lines_triangles = + transform_feedback_streams_lines_triangles.into(); + self + } + #[inline] + pub fn transform_feedback_rasterization_stream_select( + mut self, + transform_feedback_rasterization_stream_select: bool, + ) -> Self { + self.inner.transform_feedback_rasterization_stream_select = + transform_feedback_rasterization_stream_select.into(); + self + } + #[inline] + pub fn transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self { + self.inner.transform_feedback_draw = transform_feedback_draw.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationStateStreamCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationStateStreamCreateFlagsEXT, + pub rasterization_stream: u32, +} +impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(), + rasterization_stream: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationStateStreamCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; +} +impl PipelineRasterizationStateStreamCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + PipelineRasterizationStateStreamCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationStateStreamCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateStreamCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationStateStreamCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self { + self.inner.rasterization_stream = rasterization_stream; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub representative_fragment_test: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + representative_fragment_test: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; +} +impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + #[inline] + pub fn representative_fragment_test(mut self, representative_fragment_test: bool) -> Self { + self.inner.representative_fragment_test = representative_fragment_test.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub representative_fragment_test_enable: Bool32, +} +impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + representative_fragment_test_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRepresentativeFragmentTestStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; +} +impl PipelineRepresentativeFragmentTestStateCreateInfoNV { + pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + inner: PipelineRepresentativeFragmentTestStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineRepresentativeFragmentTestStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn representative_fragment_test_enable( + mut self, + representative_fragment_test_enable: bool, + ) -> Self { + self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExclusiveScissorFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub exclusive_scissor: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + exclusive_scissor: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExclusiveScissorFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; +} +impl PhysicalDeviceExclusiveScissorFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + PhysicalDeviceExclusiveScissorFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + inner: PhysicalDeviceExclusiveScissorFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceExclusiveScissorFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + #[inline] + pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self { + self.inner.exclusive_scissor = exclusive_scissor.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportExclusiveScissorStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub exclusive_scissor_count: u32, + pub p_exclusive_scissors: *const Rect2D, +} +impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + exclusive_scissor_count: u32::default(), + p_exclusive_scissors: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportExclusiveScissorStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; +} +impl PipelineViewportExclusiveScissorStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + PipelineViewportExclusiveScissorStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportExclusiveScissorStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportExclusiveScissorStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportExclusiveScissorStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn exclusive_scissors(mut self, exclusive_scissors: &'a [Rect2D]) -> Self { + self.inner.exclusive_scissor_count = exclusive_scissors.len() as _; + self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCornerSampledImageFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub corner_sampled_image: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + corner_sampled_image: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCornerSampledImageFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; +} +impl PhysicalDeviceCornerSampledImageFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + PhysicalDeviceCornerSampledImageFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + inner: PhysicalDeviceCornerSampledImageFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceCornerSampledImageFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + #[inline] + pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self { + self.inner.corner_sampled_image = corner_sampled_image.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub compute_derivative_group_quads: Bool32, + pub compute_derivative_group_linear: Bool32, +} +impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + compute_derivative_group_quads: Bool32::default(), + compute_derivative_group_linear: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceComputeShaderDerivativesFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV; +} +impl PhysicalDeviceComputeShaderDerivativesFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + #[inline] + pub fn compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self { + self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into(); + self + } + #[inline] + pub fn compute_derivative_group_linear( + mut self, + compute_derivative_group_linear: bool, + ) -> Self { + self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderImageFootprintFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_footprint: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_footprint: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderImageFootprintFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; +} +impl PhysicalDeviceShaderImageFootprintFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + PhysicalDeviceShaderImageFootprintFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + inner: PhysicalDeviceShaderImageFootprintFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceShaderImageFootprintFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + #[inline] + pub fn image_footprint(mut self, image_footprint: bool) -> Self { + self.inner.image_footprint = image_footprint.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dedicated_allocation_image_aliasing: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + dedicated_allocation_image_aliasing: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; +} +impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { + inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { + #[inline] + pub fn dedicated_allocation_image_aliasing( + mut self, + dedicated_allocation_image_aliasing: bool, + ) -> Self { + self.inner.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub indirect_copy: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + indirect_copy: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCopyMemoryIndirectFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; +} +impl PhysicalDeviceCopyMemoryIndirectFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + inner: PhysicalDeviceCopyMemoryIndirectFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCopyMemoryIndirectFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceCopyMemoryIndirectFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + #[inline] + pub fn indirect_copy(mut self, indirect_copy: bool) -> Self { + self.inner.indirect_copy = indirect_copy.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCopyMemoryIndirectFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_queues: QueueFlags, +} +impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_queues: QueueFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCopyMemoryIndirectPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; +} +impl PhysicalDeviceCopyMemoryIndirectPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + inner: PhysicalDeviceCopyMemoryIndirectPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCopyMemoryIndirectPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceCopyMemoryIndirectPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + #[inline] + pub fn supported_queues(mut self, supported_queues: QueueFlags) -> Self { + self.inner.supported_queues = supported_queues; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCopyMemoryIndirectPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryDecompressionFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_decompression: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMemoryDecompressionFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_decompression: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryDecompressionFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; +} +impl PhysicalDeviceMemoryDecompressionFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + PhysicalDeviceMemoryDecompressionFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + inner: PhysicalDeviceMemoryDecompressionFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryDecompressionFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceMemoryDecompressionFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + #[inline] + pub fn memory_decompression(mut self, memory_decompression: bool) -> Self { + self.inner.memory_decompression = memory_decompression.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryDecompressionFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryDecompressionPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub decompression_methods: MemoryDecompressionMethodFlagsNV, + pub max_decompression_indirect_count: u64, +} +impl ::std::default::Default for PhysicalDeviceMemoryDecompressionPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + decompression_methods: MemoryDecompressionMethodFlagsNV::default(), + max_decompression_indirect_count: u64::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryDecompressionPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; +} +impl PhysicalDeviceMemoryDecompressionPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + PhysicalDeviceMemoryDecompressionPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + inner: PhysicalDeviceMemoryDecompressionPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMemoryDecompressionPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceMemoryDecompressionPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + #[inline] + pub fn decompression_methods( + mut self, + decompression_methods: MemoryDecompressionMethodFlagsNV, + ) -> Self { + self.inner.decompression_methods = decompression_methods; + self + } + #[inline] + pub fn max_decompression_indirect_count( + mut self, + max_decompression_indirect_count: u64, + ) -> Self { + self.inner.max_decompression_indirect_count = max_decompression_indirect_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryDecompressionPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShadingRatePaletteNV { + pub shading_rate_palette_entry_count: u32, + pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV, +} +impl ::std::default::Default for ShadingRatePaletteNV { + #[inline] + fn default() -> Self { + Self { + shading_rate_palette_entry_count: u32::default(), + p_shading_rate_palette_entries: ::std::ptr::null(), + } + } +} +impl ShadingRatePaletteNV { + pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> { + ShadingRatePaletteNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShadingRatePaletteNVBuilder<'a> { + inner: ShadingRatePaletteNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> { + type Target = ShadingRatePaletteNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShadingRatePaletteNVBuilder<'a> { + #[inline] + pub fn shading_rate_palette_entries( + mut self, + shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV], + ) -> Self { + self.inner.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _; + self.inner.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShadingRatePaletteNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportShadingRateImageStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shading_rate_image_enable: Bool32, + pub viewport_count: u32, + pub p_shading_rate_palettes: *const ShadingRatePaletteNV, +} +impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + shading_rate_image_enable: Bool32::default(), + viewport_count: u32::default(), + p_shading_rate_palettes: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportShadingRateImageStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; +} +impl PipelineViewportShadingRateImageStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + PipelineViewportShadingRateImageStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportShadingRateImageStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportShadingRateImageStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportShadingRateImageStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self { + self.inner.shading_rate_image_enable = shading_rate_image_enable.into(); + self + } + #[inline] + pub fn shading_rate_palettes( + mut self, + shading_rate_palettes: &'a [ShadingRatePaletteNV], + ) -> Self { + self.inner.viewport_count = shading_rate_palettes.len() as _; + self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShadingRateImageFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shading_rate_image: Bool32, + pub shading_rate_coarse_sample_order: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shading_rate_image: Bool32::default(), + shading_rate_coarse_sample_order: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShadingRateImageFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; +} +impl PhysicalDeviceShadingRateImageFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + PhysicalDeviceShadingRateImageFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + inner: PhysicalDeviceShadingRateImageFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceShadingRateImageFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + #[inline] + pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self { + self.inner.shading_rate_image = shading_rate_image.into(); + self + } + #[inline] + pub fn shading_rate_coarse_sample_order( + mut self, + shading_rate_coarse_sample_order: bool, + ) -> Self { + self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShadingRateImagePropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shading_rate_texel_size: Extent2D, + pub shading_rate_palette_size: u32, + pub shading_rate_max_coarse_samples: u32, +} +impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shading_rate_texel_size: Extent2D::default(), + shading_rate_palette_size: u32::default(), + shading_rate_max_coarse_samples: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShadingRateImagePropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; +} +impl PhysicalDeviceShadingRateImagePropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + PhysicalDeviceShadingRateImagePropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + inner: PhysicalDeviceShadingRateImagePropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + type Target = PhysicalDeviceShadingRateImagePropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + #[inline] + pub fn shading_rate_texel_size(mut self, shading_rate_texel_size: Extent2D) -> Self { + self.inner.shading_rate_texel_size = shading_rate_texel_size; + self + } + #[inline] + pub fn shading_rate_palette_size(mut self, shading_rate_palette_size: u32) -> Self { + self.inner.shading_rate_palette_size = shading_rate_palette_size; + self + } + #[inline] + pub fn shading_rate_max_coarse_samples(mut self, shading_rate_max_coarse_samples: u32) -> Self { + self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub invocation_mask: Bool32, +} +impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + invocation_mask: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceInvocationMaskFeaturesHUAWEI { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; +} +impl PhysicalDeviceInvocationMaskFeaturesHUAWEI { + pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + #[inline] + pub fn invocation_mask(mut self, invocation_mask: bool) -> Self { + self.inner.invocation_mask = invocation_mask.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct CoarseSampleLocationNV { + pub pixel_x: u32, + pub pixel_y: u32, + pub sample: u32, +} +impl CoarseSampleLocationNV { + pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> { + CoarseSampleLocationNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CoarseSampleLocationNVBuilder<'a> { + inner: CoarseSampleLocationNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> { + type Target = CoarseSampleLocationNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CoarseSampleLocationNVBuilder<'a> { + #[inline] + pub fn pixel_x(mut self, pixel_x: u32) -> Self { + self.inner.pixel_x = pixel_x; + self + } + #[inline] + pub fn pixel_y(mut self, pixel_y: u32) -> Self { + self.inner.pixel_y = pixel_y; + self + } + #[inline] + pub fn sample(mut self, sample: u32) -> Self { + self.inner.sample = sample; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CoarseSampleLocationNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CoarseSampleOrderCustomNV { + pub shading_rate: ShadingRatePaletteEntryNV, + pub sample_count: u32, + pub sample_location_count: u32, + pub p_sample_locations: *const CoarseSampleLocationNV, +} +impl ::std::default::Default for CoarseSampleOrderCustomNV { + #[inline] + fn default() -> Self { + Self { + shading_rate: ShadingRatePaletteEntryNV::default(), + sample_count: u32::default(), + sample_location_count: u32::default(), + p_sample_locations: ::std::ptr::null(), + } + } +} +impl CoarseSampleOrderCustomNV { + pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> { + CoarseSampleOrderCustomNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CoarseSampleOrderCustomNVBuilder<'a> { + inner: CoarseSampleOrderCustomNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> { + type Target = CoarseSampleOrderCustomNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CoarseSampleOrderCustomNVBuilder<'a> { + #[inline] + pub fn shading_rate(mut self, shading_rate: ShadingRatePaletteEntryNV) -> Self { + self.inner.shading_rate = shading_rate; + self + } + #[inline] + pub fn sample_count(mut self, sample_count: u32) -> Self { + self.inner.sample_count = sample_count; + self + } + #[inline] + pub fn sample_locations(mut self, sample_locations: &'a [CoarseSampleLocationNV]) -> Self { + self.inner.sample_location_count = sample_locations.len() as _; + self.inner.p_sample_locations = sample_locations.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CoarseSampleOrderCustomNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_order_type: CoarseSampleOrderTypeNV, + pub custom_sample_order_count: u32, + pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV, +} +impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sample_order_type: CoarseSampleOrderTypeNV::default(), + custom_sample_order_count: u32::default(), + p_custom_sample_orders: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportCoarseSampleOrderStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; +} +impl PipelineViewportCoarseSampleOrderStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportCoarseSampleOrderStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn sample_order_type(mut self, sample_order_type: CoarseSampleOrderTypeNV) -> Self { + self.inner.sample_order_type = sample_order_type; + self + } + #[inline] + pub fn custom_sample_orders( + mut self, + custom_sample_orders: &'a [CoarseSampleOrderCustomNV], + ) -> Self { + self.inner.custom_sample_order_count = custom_sample_orders.len() as _; + self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMeshShaderFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub task_shader: Bool32, + pub mesh_shader: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + task_shader: Bool32::default(), + mesh_shader: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMeshShaderFeaturesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; +} +impl PhysicalDeviceMeshShaderFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + PhysicalDeviceMeshShaderFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + inner: PhysicalDeviceMeshShaderFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceMeshShaderFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + #[inline] + pub fn task_shader(mut self, task_shader: bool) -> Self { + self.inner.task_shader = task_shader.into(); + self + } + #[inline] + pub fn mesh_shader(mut self, mesh_shader: bool) -> Self { + self.inner.mesh_shader = mesh_shader.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMeshShaderPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_draw_mesh_tasks_count: u32, + pub max_task_work_group_invocations: u32, + pub max_task_work_group_size: [u32; 3], + pub max_task_total_memory_size: u32, + pub max_task_output_count: u32, + pub max_mesh_work_group_invocations: u32, + pub max_mesh_work_group_size: [u32; 3], + pub max_mesh_total_memory_size: u32, + pub max_mesh_output_vertices: u32, + pub max_mesh_output_primitives: u32, + pub max_mesh_multiview_view_count: u32, + pub mesh_output_per_vertex_granularity: u32, + pub mesh_output_per_primitive_granularity: u32, +} +impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_draw_mesh_tasks_count: u32::default(), + max_task_work_group_invocations: u32::default(), + max_task_work_group_size: unsafe { ::std::mem::zeroed() }, + max_task_total_memory_size: u32::default(), + max_task_output_count: u32::default(), + max_mesh_work_group_invocations: u32::default(), + max_mesh_work_group_size: unsafe { ::std::mem::zeroed() }, + max_mesh_total_memory_size: u32::default(), + max_mesh_output_vertices: u32::default(), + max_mesh_output_primitives: u32::default(), + max_mesh_multiview_view_count: u32::default(), + mesh_output_per_vertex_granularity: u32::default(), + mesh_output_per_primitive_granularity: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMeshShaderPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; +} +impl PhysicalDeviceMeshShaderPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + PhysicalDeviceMeshShaderPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + inner: PhysicalDeviceMeshShaderPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceMeshShaderPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + #[inline] + pub fn max_draw_mesh_tasks_count(mut self, max_draw_mesh_tasks_count: u32) -> Self { + self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count; + self + } + #[inline] + pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self { + self.inner.max_task_work_group_invocations = max_task_work_group_invocations; + self + } + #[inline] + pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self { + self.inner.max_task_work_group_size = max_task_work_group_size; + self + } + #[inline] + pub fn max_task_total_memory_size(mut self, max_task_total_memory_size: u32) -> Self { + self.inner.max_task_total_memory_size = max_task_total_memory_size; + self + } + #[inline] + pub fn max_task_output_count(mut self, max_task_output_count: u32) -> Self { + self.inner.max_task_output_count = max_task_output_count; + self + } + #[inline] + pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self { + self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations; + self + } + #[inline] + pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self { + self.inner.max_mesh_work_group_size = max_mesh_work_group_size; + self + } + #[inline] + pub fn max_mesh_total_memory_size(mut self, max_mesh_total_memory_size: u32) -> Self { + self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size; + self + } + #[inline] + pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self { + self.inner.max_mesh_output_vertices = max_mesh_output_vertices; + self + } + #[inline] + pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self { + self.inner.max_mesh_output_primitives = max_mesh_output_primitives; + self + } + #[inline] + pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self { + self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count; + self + } + #[inline] + pub fn mesh_output_per_vertex_granularity( + mut self, + mesh_output_per_vertex_granularity: u32, + ) -> Self { + self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity; + self + } + #[inline] + pub fn mesh_output_per_primitive_granularity( + mut self, + mesh_output_per_primitive_granularity: u32, + ) -> Self { + self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrawMeshTasksIndirectCommandNV { + pub task_count: u32, + pub first_task: u32, +} +impl DrawMeshTasksIndirectCommandNV { + pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> { + DrawMeshTasksIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> { + inner: DrawMeshTasksIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> { + type Target = DrawMeshTasksIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> { + #[inline] + pub fn task_count(mut self, task_count: u32) -> Self { + self.inner.task_count = task_count; + self + } + #[inline] + pub fn first_task(mut self, first_task: u32) -> Self { + self.inner.first_task = first_task; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrawMeshTasksIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMeshShaderFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub task_shader: Bool32, + pub mesh_shader: Bool32, + pub multiview_mesh_shader: Bool32, + pub primitive_fragment_shading_rate_mesh_shader: Bool32, + pub mesh_shader_queries: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + task_shader: Bool32::default(), + mesh_shader: Bool32::default(), + multiview_mesh_shader: Bool32::default(), + primitive_fragment_shading_rate_mesh_shader: Bool32::default(), + mesh_shader_queries: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMeshShaderFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; +} +impl PhysicalDeviceMeshShaderFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + PhysicalDeviceMeshShaderFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMeshShaderFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMeshShaderFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + #[inline] + pub fn task_shader(mut self, task_shader: bool) -> Self { + self.inner.task_shader = task_shader.into(); + self + } + #[inline] + pub fn mesh_shader(mut self, mesh_shader: bool) -> Self { + self.inner.mesh_shader = mesh_shader.into(); + self + } + #[inline] + pub fn multiview_mesh_shader(mut self, multiview_mesh_shader: bool) -> Self { + self.inner.multiview_mesh_shader = multiview_mesh_shader.into(); + self + } + #[inline] + pub fn primitive_fragment_shading_rate_mesh_shader( + mut self, + primitive_fragment_shading_rate_mesh_shader: bool, + ) -> Self { + self.inner.primitive_fragment_shading_rate_mesh_shader = + primitive_fragment_shading_rate_mesh_shader.into(); + self + } + #[inline] + pub fn mesh_shader_queries(mut self, mesh_shader_queries: bool) -> Self { + self.inner.mesh_shader_queries = mesh_shader_queries.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMeshShaderPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_task_work_group_total_count: u32, + pub max_task_work_group_count: [u32; 3], + pub max_task_work_group_invocations: u32, + pub max_task_work_group_size: [u32; 3], + pub max_task_payload_size: u32, + pub max_task_shared_memory_size: u32, + pub max_task_payload_and_shared_memory_size: u32, + pub max_mesh_work_group_total_count: u32, + pub max_mesh_work_group_count: [u32; 3], + pub max_mesh_work_group_invocations: u32, + pub max_mesh_work_group_size: [u32; 3], + pub max_mesh_shared_memory_size: u32, + pub max_mesh_payload_and_shared_memory_size: u32, + pub max_mesh_output_memory_size: u32, + pub max_mesh_payload_and_output_memory_size: u32, + pub max_mesh_output_components: u32, + pub max_mesh_output_vertices: u32, + pub max_mesh_output_primitives: u32, + pub max_mesh_output_layers: u32, + pub max_mesh_multiview_view_count: u32, + pub mesh_output_per_vertex_granularity: u32, + pub mesh_output_per_primitive_granularity: u32, + pub max_preferred_task_work_group_invocations: u32, + pub max_preferred_mesh_work_group_invocations: u32, + pub prefers_local_invocation_vertex_output: Bool32, + pub prefers_local_invocation_primitive_output: Bool32, + pub prefers_compact_vertex_output: Bool32, + pub prefers_compact_primitive_output: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_task_work_group_total_count: u32::default(), + max_task_work_group_count: unsafe { ::std::mem::zeroed() }, + max_task_work_group_invocations: u32::default(), + max_task_work_group_size: unsafe { ::std::mem::zeroed() }, + max_task_payload_size: u32::default(), + max_task_shared_memory_size: u32::default(), + max_task_payload_and_shared_memory_size: u32::default(), + max_mesh_work_group_total_count: u32::default(), + max_mesh_work_group_count: unsafe { ::std::mem::zeroed() }, + max_mesh_work_group_invocations: u32::default(), + max_mesh_work_group_size: unsafe { ::std::mem::zeroed() }, + max_mesh_shared_memory_size: u32::default(), + max_mesh_payload_and_shared_memory_size: u32::default(), + max_mesh_output_memory_size: u32::default(), + max_mesh_payload_and_output_memory_size: u32::default(), + max_mesh_output_components: u32::default(), + max_mesh_output_vertices: u32::default(), + max_mesh_output_primitives: u32::default(), + max_mesh_output_layers: u32::default(), + max_mesh_multiview_view_count: u32::default(), + mesh_output_per_vertex_granularity: u32::default(), + mesh_output_per_primitive_granularity: u32::default(), + max_preferred_task_work_group_invocations: u32::default(), + max_preferred_mesh_work_group_invocations: u32::default(), + prefers_local_invocation_vertex_output: Bool32::default(), + prefers_local_invocation_primitive_output: Bool32::default(), + prefers_compact_vertex_output: Bool32::default(), + prefers_compact_primitive_output: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMeshShaderPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; +} +impl PhysicalDeviceMeshShaderPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + PhysicalDeviceMeshShaderPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceMeshShaderPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceMeshShaderPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_task_work_group_total_count(mut self, max_task_work_group_total_count: u32) -> Self { + self.inner.max_task_work_group_total_count = max_task_work_group_total_count; + self + } + #[inline] + pub fn max_task_work_group_count(mut self, max_task_work_group_count: [u32; 3]) -> Self { + self.inner.max_task_work_group_count = max_task_work_group_count; + self + } + #[inline] + pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self { + self.inner.max_task_work_group_invocations = max_task_work_group_invocations; + self + } + #[inline] + pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self { + self.inner.max_task_work_group_size = max_task_work_group_size; + self + } + #[inline] + pub fn max_task_payload_size(mut self, max_task_payload_size: u32) -> Self { + self.inner.max_task_payload_size = max_task_payload_size; + self + } + #[inline] + pub fn max_task_shared_memory_size(mut self, max_task_shared_memory_size: u32) -> Self { + self.inner.max_task_shared_memory_size = max_task_shared_memory_size; + self + } + #[inline] + pub fn max_task_payload_and_shared_memory_size( + mut self, + max_task_payload_and_shared_memory_size: u32, + ) -> Self { + self.inner.max_task_payload_and_shared_memory_size = + max_task_payload_and_shared_memory_size; + self + } + #[inline] + pub fn max_mesh_work_group_total_count(mut self, max_mesh_work_group_total_count: u32) -> Self { + self.inner.max_mesh_work_group_total_count = max_mesh_work_group_total_count; + self + } + #[inline] + pub fn max_mesh_work_group_count(mut self, max_mesh_work_group_count: [u32; 3]) -> Self { + self.inner.max_mesh_work_group_count = max_mesh_work_group_count; + self + } + #[inline] + pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self { + self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations; + self + } + #[inline] + pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self { + self.inner.max_mesh_work_group_size = max_mesh_work_group_size; + self + } + #[inline] + pub fn max_mesh_shared_memory_size(mut self, max_mesh_shared_memory_size: u32) -> Self { + self.inner.max_mesh_shared_memory_size = max_mesh_shared_memory_size; + self + } + #[inline] + pub fn max_mesh_payload_and_shared_memory_size( + mut self, + max_mesh_payload_and_shared_memory_size: u32, + ) -> Self { + self.inner.max_mesh_payload_and_shared_memory_size = + max_mesh_payload_and_shared_memory_size; + self + } + #[inline] + pub fn max_mesh_output_memory_size(mut self, max_mesh_output_memory_size: u32) -> Self { + self.inner.max_mesh_output_memory_size = max_mesh_output_memory_size; + self + } + #[inline] + pub fn max_mesh_payload_and_output_memory_size( + mut self, + max_mesh_payload_and_output_memory_size: u32, + ) -> Self { + self.inner.max_mesh_payload_and_output_memory_size = + max_mesh_payload_and_output_memory_size; + self + } + #[inline] + pub fn max_mesh_output_components(mut self, max_mesh_output_components: u32) -> Self { + self.inner.max_mesh_output_components = max_mesh_output_components; + self + } + #[inline] + pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self { + self.inner.max_mesh_output_vertices = max_mesh_output_vertices; + self + } + #[inline] + pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self { + self.inner.max_mesh_output_primitives = max_mesh_output_primitives; + self + } + #[inline] + pub fn max_mesh_output_layers(mut self, max_mesh_output_layers: u32) -> Self { + self.inner.max_mesh_output_layers = max_mesh_output_layers; + self + } + #[inline] + pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self { + self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count; + self + } + #[inline] + pub fn mesh_output_per_vertex_granularity( + mut self, + mesh_output_per_vertex_granularity: u32, + ) -> Self { + self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity; + self + } + #[inline] + pub fn mesh_output_per_primitive_granularity( + mut self, + mesh_output_per_primitive_granularity: u32, + ) -> Self { + self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; + self + } + #[inline] + pub fn max_preferred_task_work_group_invocations( + mut self, + max_preferred_task_work_group_invocations: u32, + ) -> Self { + self.inner.max_preferred_task_work_group_invocations = + max_preferred_task_work_group_invocations; + self + } + #[inline] + pub fn max_preferred_mesh_work_group_invocations( + mut self, + max_preferred_mesh_work_group_invocations: u32, + ) -> Self { + self.inner.max_preferred_mesh_work_group_invocations = + max_preferred_mesh_work_group_invocations; + self + } + #[inline] + pub fn prefers_local_invocation_vertex_output( + mut self, + prefers_local_invocation_vertex_output: bool, + ) -> Self { + self.inner.prefers_local_invocation_vertex_output = + prefers_local_invocation_vertex_output.into(); + self + } + #[inline] + pub fn prefers_local_invocation_primitive_output( + mut self, + prefers_local_invocation_primitive_output: bool, + ) -> Self { + self.inner.prefers_local_invocation_primitive_output = + prefers_local_invocation_primitive_output.into(); + self + } + #[inline] + pub fn prefers_compact_vertex_output(mut self, prefers_compact_vertex_output: bool) -> Self { + self.inner.prefers_compact_vertex_output = prefers_compact_vertex_output.into(); + self + } + #[inline] + pub fn prefers_compact_primitive_output( + mut self, + prefers_compact_primitive_output: bool, + ) -> Self { + self.inner.prefers_compact_primitive_output = prefers_compact_primitive_output.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrawMeshTasksIndirectCommandEXT { + pub group_count_x: u32, + pub group_count_y: u32, + pub group_count_z: u32, +} +impl DrawMeshTasksIndirectCommandEXT { + pub fn builder<'a>() -> DrawMeshTasksIndirectCommandEXTBuilder<'a> { + DrawMeshTasksIndirectCommandEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrawMeshTasksIndirectCommandEXTBuilder<'a> { + inner: DrawMeshTasksIndirectCommandEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandEXTBuilder<'a> { + type Target = DrawMeshTasksIndirectCommandEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrawMeshTasksIndirectCommandEXTBuilder<'a> { + #[inline] + pub fn group_count_x(mut self, group_count_x: u32) -> Self { + self.inner.group_count_x = group_count_x; + self + } + #[inline] + pub fn group_count_y(mut self, group_count_y: u32) -> Self { + self.inner.group_count_y = group_count_y; + self + } + #[inline] + pub fn group_count_z(mut self, group_count_z: u32) -> Self { + self.inner.group_count_z = group_count_z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrawMeshTasksIndirectCommandEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingShaderGroupCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: RayTracingShaderGroupTypeKHR, + pub general_shader: u32, + pub closest_hit_shader: u32, + pub any_hit_shader: u32, + pub intersection_shader: u32, +} +impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: RayTracingShaderGroupTypeKHR::default(), + general_shader: u32::default(), + closest_hit_shader: u32::default(), + any_hit_shader: u32::default(), + intersection_shader: u32::default(), + } + } +} +unsafe impl TaggedStructure for RayTracingShaderGroupCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV; +} +impl RayTracingShaderGroupCreateInfoNV { + pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> { + RayTracingShaderGroupCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> { + inner: RayTracingShaderGroupCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> { + type Target = RayTracingShaderGroupCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn general_shader(mut self, general_shader: u32) -> Self { + self.inner.general_shader = general_shader; + self + } + #[inline] + pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self { + self.inner.closest_hit_shader = closest_hit_shader; + self + } + #[inline] + pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self { + self.inner.any_hit_shader = any_hit_shader; + self + } + #[inline] + pub fn intersection_shader(mut self, intersection_shader: u32) -> Self { + self.inner.intersection_shader = intersection_shader; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingShaderGroupCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingShaderGroupCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: RayTracingShaderGroupTypeKHR, + pub general_shader: u32, + pub closest_hit_shader: u32, + pub any_hit_shader: u32, + pub intersection_shader: u32, + pub p_shader_group_capture_replay_handle: *const c_void, +} +impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: RayTracingShaderGroupTypeKHR::default(), + general_shader: u32::default(), + closest_hit_shader: u32::default(), + any_hit_shader: u32::default(), + intersection_shader: u32::default(), + p_shader_group_capture_replay_handle: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RayTracingShaderGroupCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; +} +impl RayTracingShaderGroupCreateInfoKHR { + pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + RayTracingShaderGroupCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + inner: RayTracingShaderGroupCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + type Target = RayTracingShaderGroupCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn general_shader(mut self, general_shader: u32) -> Self { + self.inner.general_shader = general_shader; + self + } + #[inline] + pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self { + self.inner.closest_hit_shader = closest_hit_shader; + self + } + #[inline] + pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self { + self.inner.any_hit_shader = any_hit_shader; + self + } + #[inline] + pub fn intersection_shader(mut self, intersection_shader: u32) -> Self { + self.inner.intersection_shader = intersection_shader; + self + } + #[inline] + pub fn shader_group_capture_replay_handle( + mut self, + shader_group_capture_replay_handle: *const c_void, + ) -> Self { + self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingShaderGroupCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingPipelineCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub group_count: u32, + pub p_groups: *const RayTracingShaderGroupCreateInfoNV, + pub max_recursion_depth: u32, + pub layout: PipelineLayout, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, +} +impl ::std::default::Default for RayTracingPipelineCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + group_count: u32::default(), + p_groups: ::std::ptr::null(), + max_recursion_depth: u32::default(), + layout: PipelineLayout::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + } + } +} +unsafe impl TaggedStructure for RayTracingPipelineCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV; +} +impl RayTracingPipelineCreateInfoNV { + pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> { + RayTracingPipelineCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingPipelineCreateInfoNVBuilder<'a> { + inner: RayTracingPipelineCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {} +impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> { + type Target = RayTracingPipelineCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.inner.stage_count = stages.len() as _; + self.inner.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self { + self.inner.group_count = groups.len() as _; + self.inner.p_groups = groups.as_ptr(); + self + } + #[inline] + pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self { + self.inner.max_recursion_depth = max_recursion_depth; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingPipelineCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingPipelineCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub group_count: u32, + pub p_groups: *const RayTracingShaderGroupCreateInfoKHR, + pub max_pipeline_ray_recursion_depth: u32, + pub p_library_info: *const PipelineLibraryCreateInfoKHR, + pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR, + pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, + pub layout: PipelineLayout, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, +} +impl ::std::default::Default for RayTracingPipelineCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + group_count: u32::default(), + p_groups: ::std::ptr::null(), + max_pipeline_ray_recursion_depth: u32::default(), + p_library_info: ::std::ptr::null(), + p_library_interface: ::std::ptr::null(), + p_dynamic_state: ::std::ptr::null(), + layout: PipelineLayout::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + } + } +} +unsafe impl TaggedStructure for RayTracingPipelineCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR; +} +impl RayTracingPipelineCreateInfoKHR { + pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> { + RayTracingPipelineCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> { + inner: RayTracingPipelineCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRayTracingPipelineCreateInfoKHR {} +impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> { + type Target = RayTracingPipelineCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.inner.stage_count = stages.len() as _; + self.inner.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self { + self.inner.group_count = groups.len() as _; + self.inner.p_groups = groups.as_ptr(); + self + } + #[inline] + pub fn max_pipeline_ray_recursion_depth( + mut self, + max_pipeline_ray_recursion_depth: u32, + ) -> Self { + self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth; + self + } + #[inline] + pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR) -> Self { + self.inner.p_library_info = library_info; + self + } + #[inline] + pub fn library_interface( + mut self, + library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR, + ) -> Self { + self.inner.p_library_interface = library_interface; + self + } + #[inline] + pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self { + self.inner.p_dynamic_state = dynamic_state; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingPipelineCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeometryTrianglesNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_data: Buffer, + pub vertex_offset: DeviceSize, + pub vertex_count: u32, + pub vertex_stride: DeviceSize, + pub vertex_format: Format, + pub index_data: Buffer, + pub index_offset: DeviceSize, + pub index_count: u32, + pub index_type: IndexType, + pub transform_data: Buffer, + pub transform_offset: DeviceSize, +} +impl ::std::default::Default for GeometryTrianglesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_data: Buffer::default(), + vertex_offset: DeviceSize::default(), + vertex_count: u32::default(), + vertex_stride: DeviceSize::default(), + vertex_format: Format::default(), + index_data: Buffer::default(), + index_offset: DeviceSize::default(), + index_count: u32::default(), + index_type: IndexType::default(), + transform_data: Buffer::default(), + transform_offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for GeometryTrianglesNV { + const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_TRIANGLES_NV; +} +impl GeometryTrianglesNV { + pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> { + GeometryTrianglesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeometryTrianglesNVBuilder<'a> { + inner: GeometryTrianglesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> { + type Target = GeometryTrianglesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeometryTrianglesNVBuilder<'a> { + #[inline] + pub fn vertex_data(mut self, vertex_data: Buffer) -> Self { + self.inner.vertex_data = vertex_data; + self + } + #[inline] + pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> Self { + self.inner.vertex_offset = vertex_offset; + self + } + #[inline] + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.inner.vertex_count = vertex_count; + self + } + #[inline] + pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self { + self.inner.vertex_stride = vertex_stride; + self + } + #[inline] + pub fn vertex_format(mut self, vertex_format: Format) -> Self { + self.inner.vertex_format = vertex_format; + self + } + #[inline] + pub fn index_data(mut self, index_data: Buffer) -> Self { + self.inner.index_data = index_data; + self + } + #[inline] + pub fn index_offset(mut self, index_offset: DeviceSize) -> Self { + self.inner.index_offset = index_offset; + self + } + #[inline] + pub fn index_count(mut self, index_count: u32) -> Self { + self.inner.index_count = index_count; + self + } + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[inline] + pub fn transform_data(mut self, transform_data: Buffer) -> Self { + self.inner.transform_data = transform_data; + self + } + #[inline] + pub fn transform_offset(mut self, transform_offset: DeviceSize) -> Self { + self.inner.transform_offset = transform_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeometryTrianglesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeometryAABBNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub aabb_data: Buffer, + pub num_aab_bs: u32, + pub stride: u32, + pub offset: DeviceSize, +} +impl ::std::default::Default for GeometryAABBNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + aabb_data: Buffer::default(), + num_aab_bs: u32::default(), + stride: u32::default(), + offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for GeometryAABBNV { + const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_AABB_NV; +} +impl GeometryAABBNV { + pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> { + GeometryAABBNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeometryAABBNVBuilder<'a> { + inner: GeometryAABBNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> { + type Target = GeometryAABBNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeometryAABBNVBuilder<'a> { + #[inline] + pub fn aabb_data(mut self, aabb_data: Buffer) -> Self { + self.inner.aabb_data = aabb_data; + self + } + #[inline] + pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self { + self.inner.num_aab_bs = num_aab_bs; + self + } + #[inline] + pub fn stride(mut self, stride: u32) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeometryAABBNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct GeometryDataNV { + pub triangles: GeometryTrianglesNV, + pub aabbs: GeometryAABBNV, +} +impl GeometryDataNV { + pub fn builder<'a>() -> GeometryDataNVBuilder<'a> { + GeometryDataNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeometryDataNVBuilder<'a> { + inner: GeometryDataNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> { + type Target = GeometryDataNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeometryDataNVBuilder<'a> { + #[inline] + pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> Self { + self.inner.triangles = triangles; + self + } + #[inline] + pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> Self { + self.inner.aabbs = aabbs; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeometryDataNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeometryNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub geometry_type: GeometryTypeKHR, + pub geometry: GeometryDataNV, + pub flags: GeometryFlagsKHR, +} +impl ::std::default::Default for GeometryNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + geometry_type: GeometryTypeKHR::default(), + geometry: GeometryDataNV::default(), + flags: GeometryFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for GeometryNV { + const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_NV; +} +impl GeometryNV { + pub fn builder<'a>() -> GeometryNVBuilder<'a> { + GeometryNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeometryNVBuilder<'a> { + inner: GeometryNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> { + type Target = GeometryNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeometryNVBuilder<'a> { + #[inline] + pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self { + self.inner.geometry_type = geometry_type; + self + } + #[inline] + pub fn geometry(mut self, geometry: GeometryDataNV) -> Self { + self.inner.geometry = geometry; + self + } + #[inline] + pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeometryNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: AccelerationStructureTypeNV, + pub flags: BuildAccelerationStructureFlagsNV, + pub instance_count: u32, + pub geometry_count: u32, + pub p_geometries: *const GeometryNV, +} +impl ::std::default::Default for AccelerationStructureInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: AccelerationStructureTypeNV::default(), + flags: BuildAccelerationStructureFlagsNV::default(), + instance_count: u32::default(), + geometry_count: u32::default(), + p_geometries: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_INFO_NV; +} +impl AccelerationStructureInfoNV { + pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> { + AccelerationStructureInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureInfoNVBuilder<'a> { + inner: AccelerationStructureInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> { + type Target = AccelerationStructureInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureInfoNVBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: BuildAccelerationStructureFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.inner.instance_count = instance_count; + self + } + #[inline] + pub fn geometries(mut self, geometries: &'a [GeometryNV]) -> Self { + self.inner.geometry_count = geometries.len() as _; + self.inner.p_geometries = geometries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub compacted_size: DeviceSize, + pub info: AccelerationStructureInfoNV, +} +impl ::std::default::Default for AccelerationStructureCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + compacted_size: DeviceSize::default(), + info: AccelerationStructureInfoNV::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV; +} +impl AccelerationStructureCreateInfoNV { + pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> { + AccelerationStructureCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureCreateInfoNVBuilder<'a> { + inner: AccelerationStructureCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {} +impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> { + type Target = AccelerationStructureCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { + #[inline] + pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self { + self.inner.compacted_size = compacted_size; + self + } + #[inline] + pub fn info(mut self, info: AccelerationStructureInfoNV) -> Self { + self.inner.info = info; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindAccelerationStructureMemoryInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureNV, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub device_index_count: u32, + pub p_device_indices: *const u32, +} +impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureNV::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + device_index_count: u32::default(), + p_device_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BindAccelerationStructureMemoryInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV; +} +impl BindAccelerationStructureMemoryInfoNV { + pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { + BindAccelerationStructureMemoryInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> { + inner: BindAccelerationStructureMemoryInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> { + type Target = BindAccelerationStructureMemoryInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureNV, + ) -> Self { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[inline] + pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { + self.inner.device_index_count = device_indices.len() as _; + self.inner.p_device_indices = device_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindAccelerationStructureMemoryInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WriteDescriptorSetAccelerationStructureKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure_count: u32, + pub p_acceleration_structures: *const AccelerationStructureKHR, +} +impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure_count: u32::default(), + p_acceleration_structures: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for WriteDescriptorSetAccelerationStructureKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR; +} +impl WriteDescriptorSetAccelerationStructureKHR { + pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + WriteDescriptorSetAccelerationStructureKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + inner: WriteDescriptorSetAccelerationStructureKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHRBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + type Target = WriteDescriptorSetAccelerationStructureKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + #[inline] + pub fn acceleration_structures( + mut self, + acceleration_structures: &'a [AccelerationStructureKHR], + ) -> Self { + self.inner.acceleration_structure_count = acceleration_structures.len() as _; + self.inner.p_acceleration_structures = acceleration_structures.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WriteDescriptorSetAccelerationStructureKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WriteDescriptorSetAccelerationStructureNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure_count: u32, + pub p_acceleration_structures: *const AccelerationStructureNV, +} +impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure_count: u32::default(), + p_acceleration_structures: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for WriteDescriptorSetAccelerationStructureNV { + const STRUCTURE_TYPE: StructureType = + StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV; +} +impl WriteDescriptorSetAccelerationStructureNV { + pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + WriteDescriptorSetAccelerationStructureNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + inner: WriteDescriptorSetAccelerationStructureNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + type Target = WriteDescriptorSetAccelerationStructureNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + #[inline] + pub fn acceleration_structures( + mut self, + acceleration_structures: &'a [AccelerationStructureNV], + ) -> Self { + self.inner.acceleration_structure_count = acceleration_structures.len() as _; + self.inner.p_acceleration_structures = acceleration_structures.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureMemoryRequirementsInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: AccelerationStructureMemoryRequirementsTypeNV, + pub acceleration_structure: AccelerationStructureNV, +} +impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: AccelerationStructureMemoryRequirementsTypeNV::default(), + acceleration_structure: AccelerationStructureNV::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureMemoryRequirementsInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV; +} +impl AccelerationStructureMemoryRequirementsInfoNV { + pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + AccelerationStructureMemoryRequirementsInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + inner: AccelerationStructureMemoryRequirementsInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + type Target = AccelerationStructureMemoryRequirementsInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureMemoryRequirementsTypeNV) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureNV, + ) -> Self { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAccelerationStructureFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub acceleration_structure: Bool32, + pub acceleration_structure_capture_replay: Bool32, + pub acceleration_structure_indirect_build: Bool32, + pub acceleration_structure_host_commands: Bool32, + pub descriptor_binding_acceleration_structure_update_after_bind: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + acceleration_structure: Bool32::default(), + acceleration_structure_capture_replay: Bool32::default(), + acceleration_structure_indirect_build: Bool32::default(), + acceleration_structure_host_commands: Bool32::default(), + descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAccelerationStructureFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; +} +impl PhysicalDeviceAccelerationStructureFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + PhysicalDeviceAccelerationStructureFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceAccelerationStructureFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceAccelerationStructureFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + #[inline] + pub fn acceleration_structure(mut self, acceleration_structure: bool) -> Self { + self.inner.acceleration_structure = acceleration_structure.into(); + self + } + #[inline] + pub fn acceleration_structure_capture_replay( + mut self, + acceleration_structure_capture_replay: bool, + ) -> Self { + self.inner.acceleration_structure_capture_replay = + acceleration_structure_capture_replay.into(); + self + } + #[inline] + pub fn acceleration_structure_indirect_build( + mut self, + acceleration_structure_indirect_build: bool, + ) -> Self { + self.inner.acceleration_structure_indirect_build = + acceleration_structure_indirect_build.into(); + self + } + #[inline] + pub fn acceleration_structure_host_commands( + mut self, + acceleration_structure_host_commands: bool, + ) -> Self { + self.inner.acceleration_structure_host_commands = + acceleration_structure_host_commands.into(); + self + } + #[inline] + pub fn descriptor_binding_acceleration_structure_update_after_bind( + mut self, + descriptor_binding_acceleration_structure_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_acceleration_structure_update_after_bind = + descriptor_binding_acceleration_structure_update_after_bind.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_pipeline: Bool32, + pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32, + pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32, + pub ray_tracing_pipeline_trace_rays_indirect: Bool32, + pub ray_traversal_primitive_culling: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_pipeline: Bool32::default(), + ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(), + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(), + ray_tracing_pipeline_trace_rays_indirect: Bool32::default(), + ray_traversal_primitive_culling: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingPipelineFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; +} +impl PhysicalDeviceRayTracingPipelineFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingPipelineFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + #[inline] + pub fn ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self { + self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_shader_group_handle_capture_replay( + mut self, + ray_tracing_pipeline_shader_group_handle_capture_replay: bool, + ) -> Self { + self.inner + .ray_tracing_pipeline_shader_group_handle_capture_replay = + ray_tracing_pipeline_shader_group_handle_capture_replay.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed( + mut self, + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool, + ) -> Self { + self.inner + .ray_tracing_pipeline_shader_group_handle_capture_replay_mixed = + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_trace_rays_indirect( + mut self, + ray_tracing_pipeline_trace_rays_indirect: bool, + ) -> Self { + self.inner.ray_tracing_pipeline_trace_rays_indirect = + ray_tracing_pipeline_trace_rays_indirect.into(); + self + } + #[inline] + pub fn ray_traversal_primitive_culling( + mut self, + ray_traversal_primitive_culling: bool, + ) -> Self { + self.inner.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayQueryFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_query: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_query: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayQueryFeaturesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; +} +impl PhysicalDeviceRayQueryFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + PhysicalDeviceRayQueryFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayQueryFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayQueryFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + #[inline] + pub fn ray_query(mut self, ray_query: bool) -> Self { + self.inner.ray_query = ray_query.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayQueryFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAccelerationStructurePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_geometry_count: u64, + pub max_instance_count: u64, + pub max_primitive_count: u64, + pub max_per_stage_descriptor_acceleration_structures: u32, + pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, + pub max_descriptor_set_acceleration_structures: u32, + pub max_descriptor_set_update_after_bind_acceleration_structures: u32, + pub min_acceleration_structure_scratch_offset_alignment: u32, +} +impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_geometry_count: u64::default(), + max_instance_count: u64::default(), + max_primitive_count: u64::default(), + max_per_stage_descriptor_acceleration_structures: u32::default(), + max_per_stage_descriptor_update_after_bind_acceleration_structures: u32::default(), + max_descriptor_set_acceleration_structures: u32::default(), + max_descriptor_set_update_after_bind_acceleration_structures: u32::default(), + min_acceleration_structure_scratch_offset_alignment: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAccelerationStructurePropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; +} +impl PhysicalDeviceAccelerationStructurePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + PhysicalDeviceAccelerationStructurePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceAccelerationStructurePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceAccelerationStructurePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + #[inline] + pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self { + self.inner.max_geometry_count = max_geometry_count; + self + } + #[inline] + pub fn max_instance_count(mut self, max_instance_count: u64) -> Self { + self.inner.max_instance_count = max_instance_count; + self + } + #[inline] + pub fn max_primitive_count(mut self, max_primitive_count: u64) -> Self { + self.inner.max_primitive_count = max_primitive_count; + self + } + #[inline] + pub fn max_per_stage_descriptor_acceleration_structures( + mut self, + max_per_stage_descriptor_acceleration_structures: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_acceleration_structures = + max_per_stage_descriptor_acceleration_structures; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures( + mut self, + max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_acceleration_structures = + max_per_stage_descriptor_update_after_bind_acceleration_structures; + self + } + #[inline] + pub fn max_descriptor_set_acceleration_structures( + mut self, + max_descriptor_set_acceleration_structures: u32, + ) -> Self { + self.inner.max_descriptor_set_acceleration_structures = + max_descriptor_set_acceleration_structures; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_acceleration_structures( + mut self, + max_descriptor_set_update_after_bind_acceleration_structures: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_acceleration_structures = + max_descriptor_set_update_after_bind_acceleration_structures; + self + } + #[inline] + pub fn min_acceleration_structure_scratch_offset_alignment( + mut self, + min_acceleration_structure_scratch_offset_alignment: u32, + ) -> Self { + self.inner + .min_acceleration_structure_scratch_offset_alignment = + min_acceleration_structure_scratch_offset_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_group_handle_size: u32, + pub max_ray_recursion_depth: u32, + pub max_shader_group_stride: u32, + pub shader_group_base_alignment: u32, + pub shader_group_handle_capture_replay_size: u32, + pub max_ray_dispatch_invocation_count: u32, + pub shader_group_handle_alignment: u32, + pub max_ray_hit_attribute_size: u32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_group_handle_size: u32::default(), + max_ray_recursion_depth: u32::default(), + max_shader_group_stride: u32::default(), + shader_group_base_alignment: u32::default(), + shader_group_handle_capture_replay_size: u32::default(), + max_ray_dispatch_invocation_count: u32::default(), + shader_group_handle_alignment: u32::default(), + max_ray_hit_attribute_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingPipelinePropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; +} +impl PhysicalDeviceRayTracingPipelinePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingPipelinePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + #[inline] + pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self { + self.inner.shader_group_handle_size = shader_group_handle_size; + self + } + #[inline] + pub fn max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self { + self.inner.max_ray_recursion_depth = max_ray_recursion_depth; + self + } + #[inline] + pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self { + self.inner.max_shader_group_stride = max_shader_group_stride; + self + } + #[inline] + pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self { + self.inner.shader_group_base_alignment = shader_group_base_alignment; + self + } + #[inline] + pub fn shader_group_handle_capture_replay_size( + mut self, + shader_group_handle_capture_replay_size: u32, + ) -> Self { + self.inner.shader_group_handle_capture_replay_size = + shader_group_handle_capture_replay_size; + self + } + #[inline] + pub fn max_ray_dispatch_invocation_count( + mut self, + max_ray_dispatch_invocation_count: u32, + ) -> Self { + self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count; + self + } + #[inline] + pub fn shader_group_handle_alignment(mut self, shader_group_handle_alignment: u32) -> Self { + self.inner.shader_group_handle_alignment = shader_group_handle_alignment; + self + } + #[inline] + pub fn max_ray_hit_attribute_size(mut self, max_ray_hit_attribute_size: u32) -> Self { + self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_group_handle_size: u32, + pub max_recursion_depth: u32, + pub max_shader_group_stride: u32, + pub shader_group_base_alignment: u32, + pub max_geometry_count: u64, + pub max_instance_count: u64, + pub max_triangle_count: u64, + pub max_descriptor_set_acceleration_structures: u32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_group_handle_size: u32::default(), + max_recursion_depth: u32::default(), + max_shader_group_stride: u32::default(), + shader_group_base_alignment: u32::default(), + max_geometry_count: u64::default(), + max_instance_count: u64::default(), + max_triangle_count: u64::default(), + max_descriptor_set_acceleration_structures: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; +} +impl PhysicalDeviceRayTracingPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + PhysicalDeviceRayTracingPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + inner: PhysicalDeviceRayTracingPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceRayTracingPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + #[inline] + pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self { + self.inner.shader_group_handle_size = shader_group_handle_size; + self + } + #[inline] + pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self { + self.inner.max_recursion_depth = max_recursion_depth; + self + } + #[inline] + pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self { + self.inner.max_shader_group_stride = max_shader_group_stride; + self + } + #[inline] + pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self { + self.inner.shader_group_base_alignment = shader_group_base_alignment; + self + } + #[inline] + pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self { + self.inner.max_geometry_count = max_geometry_count; + self + } + #[inline] + pub fn max_instance_count(mut self, max_instance_count: u64) -> Self { + self.inner.max_instance_count = max_instance_count; + self + } + #[inline] + pub fn max_triangle_count(mut self, max_triangle_count: u64) -> Self { + self.inner.max_triangle_count = max_triangle_count; + self + } + #[inline] + pub fn max_descriptor_set_acceleration_structures( + mut self, + max_descriptor_set_acceleration_structures: u32, + ) -> Self { + self.inner.max_descriptor_set_acceleration_structures = + max_descriptor_set_acceleration_structures; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct StridedDeviceAddressRegionKHR { + pub device_address: DeviceAddress, + pub stride: DeviceSize, + pub size: DeviceSize, +} +impl StridedDeviceAddressRegionKHR { + pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> { + StridedDeviceAddressRegionKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct StridedDeviceAddressRegionKHRBuilder<'a> { + inner: StridedDeviceAddressRegionKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for StridedDeviceAddressRegionKHRBuilder<'a> { + type Target = StridedDeviceAddressRegionKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> { + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[inline] + pub fn stride(mut self, stride: DeviceSize) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> StridedDeviceAddressRegionKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct TraceRaysIndirectCommandKHR { + pub width: u32, + pub height: u32, + pub depth: u32, +} +impl TraceRaysIndirectCommandKHR { + pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> { + TraceRaysIndirectCommandKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TraceRaysIndirectCommandKHRBuilder<'a> { + inner: TraceRaysIndirectCommandKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for TraceRaysIndirectCommandKHRBuilder<'a> { + type Target = TraceRaysIndirectCommandKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn depth(mut self, depth: u32) -> Self { + self.inner.depth = depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TraceRaysIndirectCommandKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct TraceRaysIndirectCommand2KHR { + pub raygen_shader_record_address: DeviceAddress, + pub raygen_shader_record_size: DeviceSize, + pub miss_shader_binding_table_address: DeviceAddress, + pub miss_shader_binding_table_size: DeviceSize, + pub miss_shader_binding_table_stride: DeviceSize, + pub hit_shader_binding_table_address: DeviceAddress, + pub hit_shader_binding_table_size: DeviceSize, + pub hit_shader_binding_table_stride: DeviceSize, + pub callable_shader_binding_table_address: DeviceAddress, + pub callable_shader_binding_table_size: DeviceSize, + pub callable_shader_binding_table_stride: DeviceSize, + pub width: u32, + pub height: u32, + pub depth: u32, +} +impl TraceRaysIndirectCommand2KHR { + pub fn builder<'a>() -> TraceRaysIndirectCommand2KHRBuilder<'a> { + TraceRaysIndirectCommand2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TraceRaysIndirectCommand2KHRBuilder<'a> { + inner: TraceRaysIndirectCommand2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for TraceRaysIndirectCommand2KHRBuilder<'a> { + type Target = TraceRaysIndirectCommand2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommand2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TraceRaysIndirectCommand2KHRBuilder<'a> { + #[inline] + pub fn raygen_shader_record_address( + mut self, + raygen_shader_record_address: DeviceAddress, + ) -> Self { + self.inner.raygen_shader_record_address = raygen_shader_record_address; + self + } + #[inline] + pub fn raygen_shader_record_size(mut self, raygen_shader_record_size: DeviceSize) -> Self { + self.inner.raygen_shader_record_size = raygen_shader_record_size; + self + } + #[inline] + pub fn miss_shader_binding_table_address( + mut self, + miss_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.miss_shader_binding_table_address = miss_shader_binding_table_address; + self + } + #[inline] + pub fn miss_shader_binding_table_size( + mut self, + miss_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.miss_shader_binding_table_size = miss_shader_binding_table_size; + self + } + #[inline] + pub fn miss_shader_binding_table_stride( + mut self, + miss_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.miss_shader_binding_table_stride = miss_shader_binding_table_stride; + self + } + #[inline] + pub fn hit_shader_binding_table_address( + mut self, + hit_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.hit_shader_binding_table_address = hit_shader_binding_table_address; + self + } + #[inline] + pub fn hit_shader_binding_table_size( + mut self, + hit_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.hit_shader_binding_table_size = hit_shader_binding_table_size; + self + } + #[inline] + pub fn hit_shader_binding_table_stride( + mut self, + hit_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.hit_shader_binding_table_stride = hit_shader_binding_table_stride; + self + } + #[inline] + pub fn callable_shader_binding_table_address( + mut self, + callable_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.callable_shader_binding_table_address = callable_shader_binding_table_address; + self + } + #[inline] + pub fn callable_shader_binding_table_size( + mut self, + callable_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.callable_shader_binding_table_size = callable_shader_binding_table_size; + self + } + #[inline] + pub fn callable_shader_binding_table_stride( + mut self, + callable_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.callable_shader_binding_table_stride = callable_shader_binding_table_stride; + self + } + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn depth(mut self, depth: u32) -> Self { + self.inner.depth = depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TraceRaysIndirectCommand2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_maintenance1: Bool32, + pub ray_tracing_pipeline_trace_rays_indirect2: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_maintenance1: Bool32::default(), + ray_tracing_pipeline_trace_rays_indirect2: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; +} +impl PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingMaintenance1FeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingMaintenance1FeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + #[inline] + pub fn ray_tracing_maintenance1(mut self, ray_tracing_maintenance1: bool) -> Self { + self.inner.ray_tracing_maintenance1 = ray_tracing_maintenance1.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_trace_rays_indirect2( + mut self, + ray_tracing_pipeline_trace_rays_indirect2: bool, + ) -> Self { + self.inner.ray_tracing_pipeline_trace_rays_indirect2 = + ray_tracing_pipeline_trace_rays_indirect2.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DrmFormatModifierPropertiesListEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub drm_format_modifier_count: u32, + pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT, +} +impl ::std::default::Default for DrmFormatModifierPropertiesListEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + drm_format_modifier_count: u32::default(), + p_drm_format_modifier_properties: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DrmFormatModifierPropertiesListEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; +} +impl DrmFormatModifierPropertiesListEXT { + pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> { + DrmFormatModifierPropertiesListEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> { + inner: DrmFormatModifierPropertiesListEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {} +impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> { + type Target = DrmFormatModifierPropertiesListEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier_properties( + mut self, + drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT], + ) -> Self { + self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _; + self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrmFormatModifierPropertiesListEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrmFormatModifierPropertiesEXT { + pub drm_format_modifier: u64, + pub drm_format_modifier_plane_count: u32, + pub drm_format_modifier_tiling_features: FormatFeatureFlags, +} +impl DrmFormatModifierPropertiesEXT { + pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> { + DrmFormatModifierPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierPropertiesEXTBuilder<'a> { + inner: DrmFormatModifierPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> { + type Target = DrmFormatModifierPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { + self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self + } + #[inline] + pub fn drm_format_modifier_tiling_features( + mut self, + drm_format_modifier_tiling_features: FormatFeatureFlags, + ) -> Self { + self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrmFormatModifierPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub drm_format_modifier: u64, + pub sharing_mode: SharingMode, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, +} +impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + drm_format_modifier: u64::default(), + sharing_mode: SharingMode::default(), + queue_family_index_count: u32::default(), + p_queue_family_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageDrmFormatModifierInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; +} +impl PhysicalDeviceImageDrmFormatModifierInfoEXT { + pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + inner: PhysicalDeviceImageDrmFormatModifierInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 + for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { + self.inner.sharing_mode = sharing_mode; + self + } + #[inline] + pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { + self.inner.queue_family_index_count = queue_family_indices.len() as _; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageDrmFormatModifierListCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub drm_format_modifier_count: u32, + pub p_drm_format_modifiers: *const u64, +} +impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + drm_format_modifier_count: u32::default(), + p_drm_format_modifiers: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ImageDrmFormatModifierListCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; +} +impl ImageDrmFormatModifierListCreateInfoEXT { + pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + ImageDrmFormatModifierListCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + inner: ImageDrmFormatModifierListCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + type Target = ImageDrmFormatModifierListCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifiers(mut self, drm_format_modifiers: &'a [u64]) -> Self { + self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _; + self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageDrmFormatModifierExplicitCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub drm_format_modifier: u64, + pub drm_format_modifier_plane_count: u32, + pub p_plane_layouts: *const SubresourceLayout, +} +impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + drm_format_modifier: u64::default(), + drm_format_modifier_plane_count: u32::default(), + p_plane_layouts: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ImageDrmFormatModifierExplicitCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT; +} +impl ImageDrmFormatModifierExplicitCreateInfoEXT { + pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + ImageDrmFormatModifierExplicitCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + inner: ImageDrmFormatModifierExplicitCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + type Target = ImageDrmFormatModifierExplicitCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn plane_layouts(mut self, plane_layouts: &'a [SubresourceLayout]) -> Self { + self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _; + self.inner.p_plane_layouts = plane_layouts.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageDrmFormatModifierPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub drm_format_modifier: u64, +} +impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + drm_format_modifier: u64::default(), + } + } +} +unsafe impl TaggedStructure for ImageDrmFormatModifierPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; +} +impl ImageDrmFormatModifierPropertiesEXT { + pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + ImageDrmFormatModifierPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + inner: ImageDrmFormatModifierPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + type Target = ImageDrmFormatModifierPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageStencilUsageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub stencil_usage: ImageUsageFlags, +} +impl ::std::default::Default for ImageStencilUsageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + stencil_usage: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for ImageStencilUsageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO; +} +impl ImageStencilUsageCreateInfo { + pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> { + ImageStencilUsageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageStencilUsageCreateInfoBuilder<'a> { + inner: ImageStencilUsageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo {} +impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> { + type Target = ImageStencilUsageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageStencilUsageCreateInfoBuilder<'a> { + #[inline] + pub fn stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self { + self.inner.stencil_usage = stencil_usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageStencilUsageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceMemoryOverallocationCreateInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub overallocation_behavior: MemoryOverallocationBehaviorAMD, +} +impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + overallocation_behavior: MemoryOverallocationBehaviorAMD::default(), + } + } +} +unsafe impl TaggedStructure for DeviceMemoryOverallocationCreateInfoAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; +} +impl DeviceMemoryOverallocationCreateInfoAMD { + pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + DeviceMemoryOverallocationCreateInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + inner: DeviceMemoryOverallocationCreateInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {} +impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + type Target = DeviceMemoryOverallocationCreateInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + #[inline] + pub fn overallocation_behavior( + mut self, + overallocation_behavior: MemoryOverallocationBehaviorAMD, + ) -> Self { + self.inner.overallocation_behavior = overallocation_behavior; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map: Bool32, + pub fragment_density_map_dynamic: Bool32, + pub fragment_density_map_non_subsampled_images: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_density_map: Bool32::default(), + fragment_density_map_dynamic: Bool32::default(), + fragment_density_map_non_subsampled_images: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; +} +impl PhysicalDeviceFragmentDensityMapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + #[inline] + pub fn fragment_density_map(mut self, fragment_density_map: bool) -> Self { + self.inner.fragment_density_map = fragment_density_map.into(); + self + } + #[inline] + pub fn fragment_density_map_dynamic(mut self, fragment_density_map_dynamic: bool) -> Self { + self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into(); + self + } + #[inline] + pub fn fragment_density_map_non_subsampled_images( + mut self, + fragment_density_map_non_subsampled_images: bool, + ) -> Self { + self.inner.fragment_density_map_non_subsampled_images = + fragment_density_map_non_subsampled_images.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map_deferred: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_density_map_deferred: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMap2FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; +} +impl PhysicalDeviceFragmentDensityMap2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + #[inline] + pub fn fragment_density_map_deferred(mut self, fragment_density_map_deferred: bool) -> Self { + self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map_offset: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_density_map_offset: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM; +} +impl PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + #[inline] + pub fn fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self { + self.inner.fragment_density_map_offset = fragment_density_map_offset.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_fragment_density_texel_size: Extent2D, + pub max_fragment_density_texel_size: Extent2D, + pub fragment_density_invocations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_fragment_density_texel_size: Extent2D::default(), + max_fragment_density_texel_size: Extent2D::default(), + fragment_density_invocations: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; +} +impl PhysicalDeviceFragmentDensityMapPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + #[inline] + pub fn min_fragment_density_texel_size( + mut self, + min_fragment_density_texel_size: Extent2D, + ) -> Self { + self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size; + self + } + #[inline] + pub fn max_fragment_density_texel_size( + mut self, + max_fragment_density_texel_size: Extent2D, + ) -> Self { + self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size; + self + } + #[inline] + pub fn fragment_density_invocations(mut self, fragment_density_invocations: bool) -> Self { + self.inner.fragment_density_invocations = fragment_density_invocations.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subsampled_loads: Bool32, + pub subsampled_coarse_reconstruction_early_access: Bool32, + pub max_subsampled_array_layers: u32, + pub max_descriptor_set_subsampled_samplers: u32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subsampled_loads: Bool32::default(), + subsampled_coarse_reconstruction_early_access: Bool32::default(), + max_subsampled_array_layers: u32::default(), + max_descriptor_set_subsampled_samplers: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMap2PropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; +} +impl PhysicalDeviceFragmentDensityMap2PropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + #[inline] + pub fn subsampled_loads(mut self, subsampled_loads: bool) -> Self { + self.inner.subsampled_loads = subsampled_loads.into(); + self + } + #[inline] + pub fn subsampled_coarse_reconstruction_early_access( + mut self, + subsampled_coarse_reconstruction_early_access: bool, + ) -> Self { + self.inner.subsampled_coarse_reconstruction_early_access = + subsampled_coarse_reconstruction_early_access.into(); + self + } + #[inline] + pub fn max_subsampled_array_layers(mut self, max_subsampled_array_layers: u32) -> Self { + self.inner.max_subsampled_array_layers = max_subsampled_array_layers; + self + } + #[inline] + pub fn max_descriptor_set_subsampled_samplers( + mut self, + max_descriptor_set_subsampled_samplers: u32, + ) -> Self { + self.inner.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_offset_granularity: Extent2D, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_density_offset_granularity: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM; +} +impl PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + #[inline] + pub fn fragment_density_offset_granularity( + mut self, + fragment_density_offset_granularity: Extent2D, + ) -> Self { + self.inner.fragment_density_offset_granularity = fragment_density_offset_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassFragmentDensityMapCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_density_map_attachment: AttachmentReference, +} +impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fragment_density_map_attachment: AttachmentReference::default(), + } + } +} +unsafe impl TaggedStructure for RenderPassFragmentDensityMapCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; +} +impl RenderPassFragmentDensityMapCreateInfoEXT { + pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + RenderPassFragmentDensityMapCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + inner: RenderPassFragmentDensityMapCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + type Target = RenderPassFragmentDensityMapCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + #[inline] + pub fn fragment_density_map_attachment( + mut self, + fragment_density_map_attachment: AttachmentReference, + ) -> Self { + self.inner.fragment_density_map_attachment = fragment_density_map_attachment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_density_offset_count: u32, + pub p_fragment_density_offsets: *const Offset2D, +} +impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fragment_density_offset_count: u32::default(), + p_fragment_density_offsets: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubpassFragmentDensityMapOffsetEndInfoQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM; +} +impl SubpassFragmentDensityMapOffsetEndInfoQCOM { + pub fn builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + inner: SubpassFragmentDensityMapOffsetEndInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'_> {} +unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM {} +impl<'a> ::std::ops::Deref for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + type Target = SubpassFragmentDensityMapOffsetEndInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + #[inline] + pub fn fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self { + self.inner.fragment_density_offset_count = fragment_density_offsets.len() as _; + self.inner.p_fragment_density_offsets = fragment_density_offsets.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassFragmentDensityMapOffsetEndInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceScalarBlockLayoutFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub scalar_block_layout: Bool32, +} +impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + scalar_block_layout: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceScalarBlockLayoutFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; +} +impl PhysicalDeviceScalarBlockLayoutFeatures { + pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + PhysicalDeviceScalarBlockLayoutFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + inner: PhysicalDeviceScalarBlockLayoutFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + type Target = PhysicalDeviceScalarBlockLayoutFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + #[inline] + pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self { + self.inner.scalar_block_layout = scalar_block_layout.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceProtectedCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub supports_protected: Bool32, +} +impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + supports_protected: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceProtectedCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR; +} +impl SurfaceProtectedCapabilitiesKHR { + pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> { + SurfaceProtectedCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> { + inner: SurfaceProtectedCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> { + type Target = SurfaceProtectedCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn supports_protected(mut self, supports_protected: bool) -> Self { + self.inner.supports_protected = supports_protected.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceProtectedCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub uniform_buffer_standard_layout: Bool32, +} +impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + uniform_buffer_standard_layout: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceUniformBufferStandardLayoutFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; +} +impl PhysicalDeviceUniformBufferStandardLayoutFeatures { + pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + inner: PhysicalDeviceUniformBufferStandardLayoutFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUniformBufferStandardLayoutFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + #[inline] + pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self { + self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthClipEnableFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub depth_clip_enable: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + depth_clip_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDepthClipEnableFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; +} +impl PhysicalDeviceDepthClipEnableFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + PhysicalDeviceDepthClipEnableFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDepthClipEnableFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDepthClipEnableFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + #[inline] + pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self { + self.inner.depth_clip_enable = depth_clip_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationDepthClipStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT, + pub depth_clip_enable: Bool32, +} +impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(), + depth_clip_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationDepthClipStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; +} +impl PipelineRasterizationDepthClipStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationDepthClipStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationDepthClipStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationDepthClipStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationDepthClipStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self { + self.inner.depth_clip_enable = depth_clip_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryBudgetPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], + pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], +} +impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + heap_budget: unsafe { ::std::mem::zeroed() }, + heap_usage: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryBudgetPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; +} +impl PhysicalDeviceMemoryBudgetPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + PhysicalDeviceMemoryBudgetPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceMemoryBudgetPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 + for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceMemoryBudgetPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + #[inline] + pub fn heap_budget(mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self { + self.inner.heap_budget = heap_budget; + self + } + #[inline] + pub fn heap_usage(mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self { + self.inner.heap_usage = heap_usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryPriorityFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_priority: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_priority: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryPriorityFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; +} +impl PhysicalDeviceMemoryPriorityFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + PhysicalDeviceMemoryPriorityFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMemoryPriorityFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMemoryPriorityFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + #[inline] + pub fn memory_priority(mut self, memory_priority: bool) -> Self { + self.inner.memory_priority = memory_priority.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryPriorityAllocateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub priority: f32, +} +impl ::std::default::Default for MemoryPriorityAllocateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + priority: f32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryPriorityAllocateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT; +} +impl MemoryPriorityAllocateInfoEXT { + pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> { + MemoryPriorityAllocateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> { + inner: MemoryPriorityAllocateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {} +impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> { + type Target = MemoryPriorityAllocateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> { + #[inline] + pub fn priority(mut self, priority: f32) -> Self { + self.inner.priority = priority; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryPriorityAllocateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pageable_device_local_memory: Bool32, +} +impl ::std::default::Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pageable_device_local_memory: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; +} +impl PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + #[inline] + pub fn pageable_device_local_memory(mut self, pageable_device_local_memory: bool) -> Self { + self.inner.pageable_device_local_memory = pageable_device_local_memory.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBufferDeviceAddressFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer_device_address: Bool32, + pub buffer_device_address_capture_replay: Bool32, + pub buffer_device_address_multi_device: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + buffer_device_address: Bool32::default(), + buffer_device_address_capture_replay: Bool32::default(), + buffer_device_address_multi_device: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBufferDeviceAddressFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; +} +impl PhysicalDeviceBufferDeviceAddressFeatures { + pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + PhysicalDeviceBufferDeviceAddressFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + inner: PhysicalDeviceBufferDeviceAddressFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + type Target = PhysicalDeviceBufferDeviceAddressFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + #[inline] + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.inner.buffer_device_address = buffer_device_address.into(); + self + } + #[inline] + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.inner.buffer_device_address_capture_replay = + buffer_device_address_capture_replay.into(); + self + } + #[inline] + pub fn buffer_device_address_multi_device( + mut self, + buffer_device_address_multi_device: bool, + ) -> Self { + self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer_device_address: Bool32, + pub buffer_device_address_capture_replay: Bool32, + pub buffer_device_address_multi_device: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + buffer_device_address: Bool32::default(), + buffer_device_address_capture_replay: Bool32::default(), + buffer_device_address_multi_device: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBufferDeviceAddressFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; +} +impl PhysicalDeviceBufferDeviceAddressFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + #[inline] + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.inner.buffer_device_address = buffer_device_address.into(); + self + } + #[inline] + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.inner.buffer_device_address_capture_replay = + buffer_device_address_capture_replay.into(); + self + } + #[inline] + pub fn buffer_device_address_multi_device( + mut self, + buffer_device_address_multi_device: bool, + ) -> Self { + self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferDeviceAddressInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for BufferDeviceAddressInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for BufferDeviceAddressInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_INFO; +} +impl BufferDeviceAddressInfo { + pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> { + BufferDeviceAddressInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferDeviceAddressInfoBuilder<'a> { + inner: BufferDeviceAddressInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> { + type Target = BufferDeviceAddressInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferDeviceAddressInfoBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferDeviceAddressInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferOpaqueCaptureAddressCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub opaque_capture_address: u64, +} +impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + opaque_capture_address: u64::default(), + } + } +} +unsafe impl TaggedStructure for BufferOpaqueCaptureAddressCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; +} +impl BufferOpaqueCaptureAddressCreateInfo { + pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + BufferOpaqueCaptureAddressCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + inner: BufferOpaqueCaptureAddressCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfoBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo {} +impl<'a> ::std::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + type Target = BufferOpaqueCaptureAddressCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + #[inline] + pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self { + self.inner.opaque_capture_address = opaque_capture_address; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferOpaqueCaptureAddressCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferDeviceAddressCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_address: DeviceAddress, +} +impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_address: DeviceAddress::default(), + } + } +} +unsafe impl TaggedStructure for BufferDeviceAddressCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; +} +impl BufferDeviceAddressCreateInfoEXT { + pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + BufferDeviceAddressCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> { + inner: BufferDeviceAddressCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {} +impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> { + type Target = BufferDeviceAddressCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferDeviceAddressCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageViewImageFormatInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_view_type: ImageViewType, +} +impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_view_type: ImageViewType::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageViewImageFormatInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; +} +impl PhysicalDeviceImageViewImageFormatInfoEXT { + pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + PhysicalDeviceImageViewImageFormatInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + inner: PhysicalDeviceImageViewImageFormatInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 + for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + type Target = PhysicalDeviceImageViewImageFormatInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + #[inline] + pub fn image_view_type(mut self, image_view_type: ImageViewType) -> Self { + self.inner.image_view_type = image_view_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FilterCubicImageViewImageFormatPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub filter_cubic: Bool32, + pub filter_cubic_minmax: Bool32, +} +impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + filter_cubic: Bool32::default(), + filter_cubic_minmax: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for FilterCubicImageViewImageFormatPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT; +} +impl FilterCubicImageViewImageFormatPropertiesEXT { + pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + FilterCubicImageViewImageFormatPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + inner: FilterCubicImageViewImageFormatPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 + for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT {} +impl<'a> ::std::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + type Target = FilterCubicImageViewImageFormatPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + #[inline] + pub fn filter_cubic(mut self, filter_cubic: bool) -> Self { + self.inner.filter_cubic = filter_cubic.into(); + self + } + #[inline] + pub fn filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self { + self.inner.filter_cubic_minmax = filter_cubic_minmax.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FilterCubicImageViewImageFormatPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImagelessFramebufferFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub imageless_framebuffer: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + imageless_framebuffer: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImagelessFramebufferFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; +} +impl PhysicalDeviceImagelessFramebufferFeatures { + pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + PhysicalDeviceImagelessFramebufferFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + inner: PhysicalDeviceImagelessFramebufferFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + type Target = PhysicalDeviceImagelessFramebufferFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + #[inline] + pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self { + self.inner.imageless_framebuffer = imageless_framebuffer.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImagelessFramebufferFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FramebufferAttachmentsCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_image_info_count: u32, + pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo, +} +impl ::std::default::Default for FramebufferAttachmentsCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment_image_info_count: u32::default(), + p_attachment_image_infos: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for FramebufferAttachmentsCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; +} +impl FramebufferAttachmentsCreateInfo { + pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> { + FramebufferAttachmentsCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FramebufferAttachmentsCreateInfoBuilder<'a> { + inner: FramebufferAttachmentsCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfoBuilder<'_> {} +unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo {} +impl<'a> ::std::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> { + type Target = FramebufferAttachmentsCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> { + #[inline] + pub fn attachment_image_infos( + mut self, + attachment_image_infos: &'a [FramebufferAttachmentImageInfo], + ) -> Self { + self.inner.attachment_image_info_count = attachment_image_infos.len() as _; + self.inner.p_attachment_image_infos = attachment_image_infos.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FramebufferAttachmentsCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FramebufferAttachmentImageInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageCreateFlags, + pub usage: ImageUsageFlags, + pub width: u32, + pub height: u32, + pub layer_count: u32, + pub view_format_count: u32, + pub p_view_formats: *const Format, +} +impl ::std::default::Default for FramebufferAttachmentImageInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImageCreateFlags::default(), + usage: ImageUsageFlags::default(), + width: u32::default(), + height: u32::default(), + layer_count: u32::default(), + view_format_count: u32::default(), + p_view_formats: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for FramebufferAttachmentImageInfo { + const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; +} +impl FramebufferAttachmentImageInfo { + pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> { + FramebufferAttachmentImageInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FramebufferAttachmentImageInfoBuilder<'a> { + inner: FramebufferAttachmentImageInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> { + type Target = FramebufferAttachmentImageInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FramebufferAttachmentImageInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[inline] + pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self { + self.inner.view_format_count = view_formats.len() as _; + self.inner.p_view_formats = view_formats.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FramebufferAttachmentImageInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassAttachmentBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_count: u32, + pub p_attachments: *const ImageView, +} +impl ::std::default::Default for RenderPassAttachmentBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassAttachmentBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO; +} +impl RenderPassAttachmentBeginInfo { + pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> { + RenderPassAttachmentBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassAttachmentBeginInfoBuilder<'a> { + inner: RenderPassAttachmentBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo {} +impl<'a> ::std::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> { + type Target = RenderPassAttachmentBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> { + #[inline] + pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassAttachmentBeginInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub texture_compression_astc_hdr: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + texture_compression_astc_hdr: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTextureCompressionASTCHDRFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; +} +impl PhysicalDeviceTextureCompressionASTCHDRFeatures { + pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + inner: PhysicalDeviceTextureCompressionASTCHDRFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + type Target = PhysicalDeviceTextureCompressionASTCHDRFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + #[inline] + pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self { + self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCooperativeMatrixFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cooperative_matrix: Bool32, + pub cooperative_matrix_robust_buffer_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + cooperative_matrix: Bool32::default(), + cooperative_matrix_robust_buffer_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCooperativeMatrixFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; +} +impl PhysicalDeviceCooperativeMatrixFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + PhysicalDeviceCooperativeMatrixFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + inner: PhysicalDeviceCooperativeMatrixFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceCooperativeMatrixFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + #[inline] + pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self { + self.inner.cooperative_matrix = cooperative_matrix.into(); + self + } + #[inline] + pub fn cooperative_matrix_robust_buffer_access( + mut self, + cooperative_matrix_robust_buffer_access: bool, + ) -> Self { + self.inner.cooperative_matrix_robust_buffer_access = + cooperative_matrix_robust_buffer_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCooperativeMatrixPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cooperative_matrix_supported_stages: ShaderStageFlags, +} +impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + cooperative_matrix_supported_stages: ShaderStageFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCooperativeMatrixPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; +} +impl PhysicalDeviceCooperativeMatrixPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + PhysicalDeviceCooperativeMatrixPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + inner: PhysicalDeviceCooperativeMatrixPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceCooperativeMatrixPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + #[inline] + pub fn cooperative_matrix_supported_stages( + mut self, + cooperative_matrix_supported_stages: ShaderStageFlags, + ) -> Self { + self.inner.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CooperativeMatrixPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub m_size: u32, + pub n_size: u32, + pub k_size: u32, + pub a_type: ComponentTypeNV, + pub b_type: ComponentTypeNV, + pub c_type: ComponentTypeNV, + pub d_type: ComponentTypeNV, + pub scope: ScopeNV, +} +impl ::std::default::Default for CooperativeMatrixPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + m_size: u32::default(), + n_size: u32::default(), + k_size: u32::default(), + a_type: ComponentTypeNV::default(), + b_type: ComponentTypeNV::default(), + c_type: ComponentTypeNV::default(), + d_type: ComponentTypeNV::default(), + scope: ScopeNV::default(), + } + } +} +unsafe impl TaggedStructure for CooperativeMatrixPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV; +} +impl CooperativeMatrixPropertiesNV { + pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> { + CooperativeMatrixPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CooperativeMatrixPropertiesNVBuilder<'a> { + inner: CooperativeMatrixPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> { + type Target = CooperativeMatrixPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> { + #[inline] + pub fn m_size(mut self, m_size: u32) -> Self { + self.inner.m_size = m_size; + self + } + #[inline] + pub fn n_size(mut self, n_size: u32) -> Self { + self.inner.n_size = n_size; + self + } + #[inline] + pub fn k_size(mut self, k_size: u32) -> Self { + self.inner.k_size = k_size; + self + } + #[inline] + pub fn a_type(mut self, a_type: ComponentTypeNV) -> Self { + self.inner.a_type = a_type; + self + } + #[inline] + pub fn b_type(mut self, b_type: ComponentTypeNV) -> Self { + self.inner.b_type = b_type; + self + } + #[inline] + pub fn c_type(mut self, c_type: ComponentTypeNV) -> Self { + self.inner.c_type = c_type; + self + } + #[inline] + pub fn d_type(mut self, d_type: ComponentTypeNV) -> Self { + self.inner.d_type = d_type; + self + } + #[inline] + pub fn scope(mut self, scope: ScopeNV) -> Self { + self.inner.scope = scope; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CooperativeMatrixPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ycbcr_image_arrays: Bool32, +} +impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ycbcr_image_arrays: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceYcbcrImageArraysFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; +} +impl PhysicalDeviceYcbcrImageArraysFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + #[inline] + pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self { + self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewHandleInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub descriptor_type: DescriptorType, + pub sampler: Sampler, +} +impl ::std::default::Default for ImageViewHandleInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + descriptor_type: DescriptorType::default(), + sampler: Sampler::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewHandleInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_HANDLE_INFO_NVX; +} +impl ImageViewHandleInfoNVX { + pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> { + ImageViewHandleInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewHandleInfoNVXBuilder<'a> { + inner: ImageViewHandleInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> { + type Target = ImageViewHandleInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewHandleInfoNVXBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { + self.inner.descriptor_type = descriptor_type; + self + } + #[inline] + pub fn sampler(mut self, sampler: Sampler) -> Self { + self.inner.sampler = sampler; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewHandleInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewAddressPropertiesNVX { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_address: DeviceAddress, + pub size: DeviceSize, +} +impl ::std::default::Default for ImageViewAddressPropertiesNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_address: DeviceAddress::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewAddressPropertiesNVX { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX; +} +impl ImageViewAddressPropertiesNVX { + pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> { + ImageViewAddressPropertiesNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewAddressPropertiesNVXBuilder<'a> { + inner: ImageViewAddressPropertiesNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> { + type Target = ImageViewAddressPropertiesNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> { + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewAddressPropertiesNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentFrameTokenGGP { + pub s_type: StructureType, + pub p_next: *const c_void, + pub frame_token: GgpFrameToken, +} +impl ::std::default::Default for PresentFrameTokenGGP { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + frame_token: GgpFrameToken::default(), + } + } +} +unsafe impl TaggedStructure for PresentFrameTokenGGP { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_FRAME_TOKEN_GGP; +} +impl PresentFrameTokenGGP { + pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> { + PresentFrameTokenGGPBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentFrameTokenGGPBuilder<'a> { + inner: PresentFrameTokenGGP, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGPBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP {} +impl<'a> ::std::ops::Deref for PresentFrameTokenGGPBuilder<'a> { + type Target = PresentFrameTokenGGP; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentFrameTokenGGPBuilder<'a> { + #[inline] + pub fn frame_token(mut self, frame_token: GgpFrameToken) -> Self { + self.inner.frame_token = frame_token; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentFrameTokenGGP { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PipelineCreationFeedback { + pub flags: PipelineCreationFeedbackFlags, + pub duration: u64, +} +impl PipelineCreationFeedback { + pub fn builder<'a>() -> PipelineCreationFeedbackBuilder<'a> { + PipelineCreationFeedbackBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCreationFeedbackBuilder<'a> { + inner: PipelineCreationFeedback, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCreationFeedbackBuilder<'a> { + type Target = PipelineCreationFeedback; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCreationFeedbackBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreationFeedbackFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn duration(mut self, duration: u64) -> Self { + self.inner.duration = duration; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCreationFeedback { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCreationFeedbackCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_pipeline_creation_feedback: *mut PipelineCreationFeedback, + pub pipeline_stage_creation_feedback_count: u32, + pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback, +} +impl ::std::default::Default for PipelineCreationFeedbackCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_pipeline_creation_feedback: ::std::ptr::null_mut(), + pipeline_stage_creation_feedback_count: u32::default(), + p_pipeline_stage_creation_feedbacks: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for PipelineCreationFeedbackCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO; +} +impl PipelineCreationFeedbackCreateInfo { + pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a> { + PipelineCreationFeedbackCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCreationFeedbackCreateInfoBuilder<'a> { + inner: PipelineCreationFeedbackCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo {} +unsafe impl ExtendsRayTracingPipelineCreateInfoNV + for PipelineCreationFeedbackCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR + for PipelineCreationFeedbackCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoBuilder<'a> { + type Target = PipelineCreationFeedbackCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCreationFeedbackCreateInfoBuilder<'a> { + #[inline] + pub fn pipeline_creation_feedback( + mut self, + pipeline_creation_feedback: &'a mut PipelineCreationFeedback, + ) -> Self { + self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback; + self + } + #[inline] + pub fn pipeline_stage_creation_feedbacks( + mut self, + pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedback], + ) -> Self { + self.inner.pipeline_stage_creation_feedback_count = + pipeline_stage_creation_feedbacks.len() as _; + self.inner.p_pipeline_stage_creation_feedbacks = + pipeline_stage_creation_feedbacks.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCreationFeedbackCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceFullScreenExclusiveInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub full_screen_exclusive: FullScreenExclusiveEXT, +} +impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + full_screen_exclusive: FullScreenExclusiveEXT::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceFullScreenExclusiveInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; +} +impl SurfaceFullScreenExclusiveInfoEXT { + pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + SurfaceFullScreenExclusiveInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + inner: SurfaceFullScreenExclusiveInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT {} +impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + type Target = SurfaceFullScreenExclusiveInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + #[inline] + pub fn full_screen_exclusive(mut self, full_screen_exclusive: FullScreenExclusiveEXT) -> Self { + self.inner.full_screen_exclusive = full_screen_exclusive; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceFullScreenExclusiveInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceFullScreenExclusiveWin32InfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub hmonitor: HMONITOR, +} +impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + hmonitor: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for SurfaceFullScreenExclusiveWin32InfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; +} +impl SurfaceFullScreenExclusiveWin32InfoEXT { + pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + SurfaceFullScreenExclusiveWin32InfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + inner: SurfaceFullScreenExclusiveWin32InfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR + for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT {} +impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + type Target = SurfaceFullScreenExclusiveWin32InfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + #[inline] + pub fn hmonitor(mut self, hmonitor: HMONITOR) -> Self { + self.inner.hmonitor = hmonitor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilitiesFullScreenExclusiveEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub full_screen_exclusive_supported: Bool32, +} +impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + full_screen_exclusive_supported: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceCapabilitiesFullScreenExclusiveEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; +} +impl SurfaceCapabilitiesFullScreenExclusiveEXT { + pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + SurfaceCapabilitiesFullScreenExclusiveEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + inner: SurfaceCapabilitiesFullScreenExclusiveEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR + for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'_> +{ +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT {} +impl<'a> ::std::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + type Target = SurfaceCapabilitiesFullScreenExclusiveEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + #[inline] + pub fn full_screen_exclusive_supported( + mut self, + full_screen_exclusive_supported: bool, + ) -> Self { + self.inner.full_screen_exclusive_supported = full_screen_exclusive_supported.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentBarrierFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentBarrierFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePresentBarrierFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; +} +impl PhysicalDevicePresentBarrierFeaturesNV { + pub fn builder<'a>() -> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + PhysicalDevicePresentBarrierFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + inner: PhysicalDevicePresentBarrierFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + type Target = PhysicalDevicePresentBarrierFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + #[inline] + pub fn present_barrier(mut self, present_barrier: bool) -> Self { + self.inner.present_barrier = present_barrier.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePresentBarrierFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilitiesPresentBarrierNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier_supported: Bool32, +} +impl ::std::default::Default for SurfaceCapabilitiesPresentBarrierNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier_supported: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceCapabilitiesPresentBarrierNV { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; +} +impl SurfaceCapabilitiesPresentBarrierNV { + pub fn builder<'a>() -> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + SurfaceCapabilitiesPresentBarrierNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + inner: SurfaceCapabilitiesPresentBarrierNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNVBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNV {} +impl<'a> ::std::ops::Deref for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + type Target = SurfaceCapabilitiesPresentBarrierNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + #[inline] + pub fn present_barrier_supported(mut self, present_barrier_supported: bool) -> Self { + self.inner.present_barrier_supported = present_barrier_supported.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilitiesPresentBarrierNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentBarrierCreateInfoNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier_enable: Bool32, +} +impl ::std::default::Default for SwapchainPresentBarrierCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentBarrierCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; +} +impl SwapchainPresentBarrierCreateInfoNV { + pub fn builder<'a>() -> SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + SwapchainPresentBarrierCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + inner: SwapchainPresentBarrierCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNV {} +impl<'a> ::std::ops::Deref for SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + type Target = SwapchainPresentBarrierCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + #[inline] + pub fn present_barrier_enable(mut self, present_barrier_enable: bool) -> Self { + self.inner.present_barrier_enable = present_barrier_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentBarrierCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePerformanceQueryFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub performance_counter_query_pools: Bool32, + pub performance_counter_multiple_query_pools: Bool32, +} +impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + performance_counter_query_pools: Bool32::default(), + performance_counter_multiple_query_pools: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePerformanceQueryFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; +} +impl PhysicalDevicePerformanceQueryFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + PhysicalDevicePerformanceQueryFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePerformanceQueryFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePerformanceQueryFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + #[inline] + pub fn performance_counter_query_pools( + mut self, + performance_counter_query_pools: bool, + ) -> Self { + self.inner.performance_counter_query_pools = performance_counter_query_pools.into(); + self + } + #[inline] + pub fn performance_counter_multiple_query_pools( + mut self, + performance_counter_multiple_query_pools: bool, + ) -> Self { + self.inner.performance_counter_multiple_query_pools = + performance_counter_multiple_query_pools.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePerformanceQueryPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub allow_command_buffer_query_copies: Bool32, +} +impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + allow_command_buffer_query_copies: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePerformanceQueryPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; +} +impl PhysicalDevicePerformanceQueryPropertiesKHR { + pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + PhysicalDevicePerformanceQueryPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + inner: PhysicalDevicePerformanceQueryPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + type Target = PhysicalDevicePerformanceQueryPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + #[inline] + pub fn allow_command_buffer_query_copies( + mut self, + allow_command_buffer_query_copies: bool, + ) -> Self { + self.inner.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceCounterKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub unit: PerformanceCounterUnitKHR, + pub scope: PerformanceCounterScopeKHR, + pub storage: PerformanceCounterStorageKHR, + pub uuid: [u8; UUID_SIZE], +} +impl ::std::default::Default for PerformanceCounterKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + unit: PerformanceCounterUnitKHR::default(), + scope: PerformanceCounterScopeKHR::default(), + storage: PerformanceCounterStorageKHR::default(), + uuid: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PerformanceCounterKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_COUNTER_KHR; +} +impl PerformanceCounterKHR { + pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> { + PerformanceCounterKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceCounterKHRBuilder<'a> { + inner: PerformanceCounterKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> { + type Target = PerformanceCounterKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceCounterKHRBuilder<'a> { + #[inline] + pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> Self { + self.inner.unit = unit; + self + } + #[inline] + pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> Self { + self.inner.scope = scope; + self + } + #[inline] + pub fn storage(mut self, storage: PerformanceCounterStorageKHR) -> Self { + self.inner.storage = storage; + self + } + #[inline] + pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> Self { + self.inner.uuid = uuid; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceCounterKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceCounterDescriptionKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: PerformanceCounterDescriptionFlagsKHR, + pub name: [c_char; MAX_DESCRIPTION_SIZE], + pub category: [c_char; MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], +} +#[cfg(feature = "debug")] +impl fmt::Debug for PerformanceCounterDescriptionKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PerformanceCounterDescriptionKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("category", &unsafe { + ::std::ffi::CStr::from_ptr(self.category.as_ptr()) + }) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .finish() + } +} +impl ::std::default::Default for PerformanceCounterDescriptionKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: PerformanceCounterDescriptionFlagsKHR::default(), + name: unsafe { ::std::mem::zeroed() }, + category: unsafe { ::std::mem::zeroed() }, + description: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PerformanceCounterDescriptionKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR; +} +impl PerformanceCounterDescriptionKHR { + pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> { + PerformanceCounterDescriptionKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceCounterDescriptionKHRBuilder<'a> { + inner: PerformanceCounterDescriptionKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> { + type Target = PerformanceCounterDescriptionKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PerformanceCounterDescriptionFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn category(mut self, category: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.category = category; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceCounterDescriptionKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueryPoolPerformanceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue_family_index: u32, + pub counter_index_count: u32, + pub p_counter_indices: *const u32, +} +impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + queue_family_index: u32::default(), + counter_index_count: u32::default(), + p_counter_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for QueryPoolPerformanceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR; +} +impl QueryPoolPerformanceCreateInfoKHR { + pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + QueryPoolPerformanceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + inner: QueryPoolPerformanceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR {} +impl<'a> ::std::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + type Target = QueryPoolPerformanceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[inline] + pub fn counter_indices(mut self, counter_indices: &'a [u32]) -> Self { + self.inner.counter_index_count = counter_indices.len() as _; + self.inner.p_counter_indices = counter_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueryPoolPerformanceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union PerformanceCounterResultKHR { + pub int32: i32, + pub int64: i64, + pub uint32: u32, + pub uint64: u64, + pub float32: f32, + pub float64: f64, +} +impl ::std::default::Default for PerformanceCounterResultKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AcquireProfilingLockInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: AcquireProfilingLockFlagsKHR, + pub timeout: u64, +} +impl ::std::default::Default for AcquireProfilingLockInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: AcquireProfilingLockFlagsKHR::default(), + timeout: u64::default(), + } + } +} +unsafe impl TaggedStructure for AcquireProfilingLockInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR; +} +impl AcquireProfilingLockInfoKHR { + pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> { + AcquireProfilingLockInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AcquireProfilingLockInfoKHRBuilder<'a> { + inner: AcquireProfilingLockInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> { + type Target = AcquireProfilingLockInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: AcquireProfilingLockFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn timeout(mut self, timeout: u64) -> Self { + self.inner.timeout = timeout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AcquireProfilingLockInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceQuerySubmitInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub counter_pass_index: u32, +} +impl ::std::default::Default for PerformanceQuerySubmitInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + counter_pass_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceQuerySubmitInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR; +} +impl PerformanceQuerySubmitInfoKHR { + pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> { + PerformanceQuerySubmitInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> { + inner: PerformanceQuerySubmitInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {} +unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR {} +impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> { + type Target = PerformanceQuerySubmitInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> { + #[inline] + pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self { + self.inner.counter_pass_index = counter_pass_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceQuerySubmitInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct HeadlessSurfaceCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: HeadlessSurfaceCreateFlagsEXT, +} +impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: HeadlessSurfaceCreateFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for HeadlessSurfaceCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT; +} +impl HeadlessSurfaceCreateInfoEXT { + pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> { + HeadlessSurfaceCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> { + inner: HeadlessSurfaceCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> { + type Target = HeadlessSurfaceCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: HeadlessSurfaceCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> HeadlessSurfaceCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCoverageReductionModeFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub coverage_reduction_mode: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + coverage_reduction_mode: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCoverageReductionModeFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; +} +impl PhysicalDeviceCoverageReductionModeFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + PhysicalDeviceCoverageReductionModeFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + inner: PhysicalDeviceCoverageReductionModeFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceCoverageReductionModeFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + #[inline] + pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self { + self.inner.coverage_reduction_mode = coverage_reduction_mode.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCoverageReductionStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCoverageReductionStateCreateFlagsNV, + pub coverage_reduction_mode: CoverageReductionModeNV, +} +impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCoverageReductionStateCreateFlagsNV::default(), + coverage_reduction_mode: CoverageReductionModeNV::default(), + } + } +} +unsafe impl TaggedStructure for PipelineCoverageReductionStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; +} +impl PipelineCoverageReductionStateCreateInfoNV { + pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + PipelineCoverageReductionStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + inner: PipelineCoverageReductionStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageReductionStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageReductionStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + type Target = PipelineCoverageReductionStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCoverageReductionStateCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn coverage_reduction_mode( + mut self, + coverage_reduction_mode: CoverageReductionModeNV, + ) -> Self { + self.inner.coverage_reduction_mode = coverage_reduction_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCoverageReductionStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FramebufferMixedSamplesCombinationNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub coverage_reduction_mode: CoverageReductionModeNV, + pub rasterization_samples: SampleCountFlags, + pub depth_stencil_samples: SampleCountFlags, + pub color_samples: SampleCountFlags, +} +impl ::std::default::Default for FramebufferMixedSamplesCombinationNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + coverage_reduction_mode: CoverageReductionModeNV::default(), + rasterization_samples: SampleCountFlags::default(), + depth_stencil_samples: SampleCountFlags::default(), + color_samples: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for FramebufferMixedSamplesCombinationNV { + const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV; +} +impl FramebufferMixedSamplesCombinationNV { + pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> { + FramebufferMixedSamplesCombinationNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> { + inner: FramebufferMixedSamplesCombinationNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> { + type Target = FramebufferMixedSamplesCombinationNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> { + #[inline] + pub fn coverage_reduction_mode( + mut self, + coverage_reduction_mode: CoverageReductionModeNV, + ) -> Self { + self.inner.coverage_reduction_mode = coverage_reduction_mode; + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[inline] + pub fn depth_stencil_samples(mut self, depth_stencil_samples: SampleCountFlags) -> Self { + self.inner.depth_stencil_samples = depth_stencil_samples; + self + } + #[inline] + pub fn color_samples(mut self, color_samples: SampleCountFlags) -> Self { + self.inner.color_samples = color_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FramebufferMixedSamplesCombinationNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_integer_functions2: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_integer_functions2: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; +} +impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + #[inline] + pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self { + self.inner.shader_integer_functions2 = shader_integer_functions2.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union PerformanceValueDataINTEL { + pub value32: u32, + pub value64: u64, + pub value_float: f32, + pub value_bool: Bool32, + pub value_string: *const c_char, +} +impl ::std::default::Default for PerformanceValueDataINTEL { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PerformanceValueINTEL { + pub ty: PerformanceValueTypeINTEL, + pub data: PerformanceValueDataINTEL, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PerformanceValueINTEL { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PerformanceValueINTEL") + .field("ty", &self.ty) + .field("data", &"union") + .finish() + } +} +impl PerformanceValueINTEL { + pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> { + PerformanceValueINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceValueINTELBuilder<'a> { + inner: PerformanceValueINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceValueINTELBuilder<'a> { + type Target = PerformanceValueINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceValueINTELBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn data(mut self, data: PerformanceValueDataINTEL) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceValueINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct InitializePerformanceApiInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_user_data: *mut c_void, +} +impl ::std::default::Default for InitializePerformanceApiInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for InitializePerformanceApiInfoINTEL { + const STRUCTURE_TYPE: StructureType = StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL; +} +impl InitializePerformanceApiInfoINTEL { + pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> { + InitializePerformanceApiInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct InitializePerformanceApiInfoINTELBuilder<'a> { + inner: InitializePerformanceApiInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> { + type Target = InitializePerformanceApiInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> { + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> InitializePerformanceApiInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueryPoolPerformanceQueryCreateInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub performance_counters_sampling: QueryPoolSamplingModeINTEL, +} +impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + performance_counters_sampling: QueryPoolSamplingModeINTEL::default(), + } + } +} +unsafe impl TaggedStructure for QueryPoolPerformanceQueryCreateInfoINTEL { + const STRUCTURE_TYPE: StructureType = + StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; +} +impl QueryPoolPerformanceQueryCreateInfoINTEL { + pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + QueryPoolPerformanceQueryCreateInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + inner: QueryPoolPerformanceQueryCreateInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL {} +impl<'a> ::std::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + type Target = QueryPoolPerformanceQueryCreateInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + #[inline] + pub fn performance_counters_sampling( + mut self, + performance_counters_sampling: QueryPoolSamplingModeINTEL, + ) -> Self { + self.inner.performance_counters_sampling = performance_counters_sampling; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceMarkerInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub marker: u64, +} +impl ::std::default::Default for PerformanceMarkerInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + marker: u64::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceMarkerInfoINTEL { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_MARKER_INFO_INTEL; +} +impl PerformanceMarkerInfoINTEL { + pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> { + PerformanceMarkerInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceMarkerInfoINTELBuilder<'a> { + inner: PerformanceMarkerInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> { + type Target = PerformanceMarkerInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceMarkerInfoINTELBuilder<'a> { + #[inline] + pub fn marker(mut self, marker: u64) -> Self { + self.inner.marker = marker; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceMarkerInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceStreamMarkerInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub marker: u32, +} +impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + marker: u32::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceStreamMarkerInfoINTEL { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL; +} +impl PerformanceStreamMarkerInfoINTEL { + pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> { + PerformanceStreamMarkerInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> { + inner: PerformanceStreamMarkerInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> { + type Target = PerformanceStreamMarkerInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> { + #[inline] + pub fn marker(mut self, marker: u32) -> Self { + self.inner.marker = marker; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceStreamMarkerInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceOverrideInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: PerformanceOverrideTypeINTEL, + pub enable: Bool32, + pub parameter: u64, +} +impl ::std::default::Default for PerformanceOverrideInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: PerformanceOverrideTypeINTEL::default(), + enable: Bool32::default(), + parameter: u64::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceOverrideInfoINTEL { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL; +} +impl PerformanceOverrideInfoINTEL { + pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> { + PerformanceOverrideInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceOverrideInfoINTELBuilder<'a> { + inner: PerformanceOverrideInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> { + type Target = PerformanceOverrideInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceOverrideInfoINTELBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: PerformanceOverrideTypeINTEL) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn enable(mut self, enable: bool) -> Self { + self.inner.enable = enable.into(); + self + } + #[inline] + pub fn parameter(mut self, parameter: u64) -> Self { + self.inner.parameter = parameter; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceOverrideInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceConfigurationAcquireInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: PerformanceConfigurationTypeINTEL, +} +impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: PerformanceConfigurationTypeINTEL::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceConfigurationAcquireInfoINTEL { + const STRUCTURE_TYPE: StructureType = + StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL; +} +impl PerformanceConfigurationAcquireInfoINTEL { + pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + PerformanceConfigurationAcquireInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + inner: PerformanceConfigurationAcquireInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + type Target = PerformanceConfigurationAcquireInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: PerformanceConfigurationTypeINTEL) -> Self { + self.inner.ty = ty; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceConfigurationAcquireInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderClockFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_subgroup_clock: Bool32, + pub shader_device_clock: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_subgroup_clock: Bool32::default(), + shader_device_clock: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderClockFeaturesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; +} +impl PhysicalDeviceShaderClockFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + PhysicalDeviceShaderClockFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceShaderClockFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceShaderClockFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + #[inline] + pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self { + self.inner.shader_subgroup_clock = shader_subgroup_clock.into(); + self + } + #[inline] + pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self { + self.inner.shader_device_clock = shader_device_clock.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderClockFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub index_type_uint8: Bool32, +} +impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + index_type_uint8: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceIndexTypeUint8FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT; +} +impl PhysicalDeviceIndexTypeUint8FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceIndexTypeUint8FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceIndexTypeUint8FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + #[inline] + pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self { + self.inner.index_type_uint8 = index_type_uint8.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_sm_count: u32, + pub shader_warps_per_sm: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_sm_count: u32::default(), + shader_warps_per_sm: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderSMBuiltinsPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; +} +impl PhysicalDeviceShaderSMBuiltinsPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + #[inline] + pub fn shader_sm_count(mut self, shader_sm_count: u32) -> Self { + self.inner.shader_sm_count = shader_sm_count; + self + } + #[inline] + pub fn shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self { + self.inner.shader_warps_per_sm = shader_warps_per_sm; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_sm_builtins: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_sm_builtins: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderSMBuiltinsFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; +} +impl PhysicalDeviceShaderSMBuiltinsFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + #[inline] + pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self { + self.inner.shader_sm_builtins = shader_sm_builtins.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shader_sample_interlock: Bool32, + pub fragment_shader_pixel_interlock: Bool32, + pub fragment_shader_shading_rate_interlock: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_shader_sample_interlock: Bool32::default(), + fragment_shader_pixel_interlock: Bool32::default(), + fragment_shader_shading_rate_interlock: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; +} +impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + #[inline] + pub fn fragment_shader_sample_interlock( + mut self, + fragment_shader_sample_interlock: bool, + ) -> Self { + self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into(); + self + } + #[inline] + pub fn fragment_shader_pixel_interlock( + mut self, + fragment_shader_pixel_interlock: bool, + ) -> Self { + self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into(); + self + } + #[inline] + pub fn fragment_shader_shading_rate_interlock( + mut self, + fragment_shader_shading_rate_interlock: bool, + ) -> Self { + self.inner.fragment_shader_shading_rate_interlock = + fragment_shader_shading_rate_interlock.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub separate_depth_stencil_layouts: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + separate_depth_stencil_layouts: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; +} +impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + #[inline] + pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self { + self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentReferenceStencilLayout { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stencil_layout: ImageLayout, +} +impl ::std::default::Default for AttachmentReferenceStencilLayout { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stencil_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentReferenceStencilLayout { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT; +} +impl AttachmentReferenceStencilLayout { + pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> { + AttachmentReferenceStencilLayoutBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentReferenceStencilLayoutBuilder<'a> { + inner: AttachmentReferenceStencilLayout, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayoutBuilder<'_> {} +unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout {} +impl<'a> ::std::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> { + type Target = AttachmentReferenceStencilLayout; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> { + #[inline] + pub fn stencil_layout(mut self, stencil_layout: ImageLayout) -> Self { + self.inner.stencil_layout = stencil_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentReferenceStencilLayout { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub primitive_topology_list_restart: Bool32, + pub primitive_topology_patch_list_restart: Bool32, +} +impl ::std::default::Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + primitive_topology_list_restart: Bool32::default(), + primitive_topology_patch_list_restart: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; +} +impl PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + #[inline] + pub fn primitive_topology_list_restart( + mut self, + primitive_topology_list_restart: bool, + ) -> Self { + self.inner.primitive_topology_list_restart = primitive_topology_list_restart.into(); + self + } + #[inline] + pub fn primitive_topology_patch_list_restart( + mut self, + primitive_topology_patch_list_restart: bool, + ) -> Self { + self.inner.primitive_topology_patch_list_restart = + primitive_topology_patch_list_restart.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentDescriptionStencilLayout { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stencil_initial_layout: ImageLayout, + pub stencil_final_layout: ImageLayout, +} +impl ::std::default::Default for AttachmentDescriptionStencilLayout { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stencil_initial_layout: ImageLayout::default(), + stencil_final_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentDescriptionStencilLayout { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; +} +impl AttachmentDescriptionStencilLayout { + pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> { + AttachmentDescriptionStencilLayoutBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentDescriptionStencilLayoutBuilder<'a> { + inner: AttachmentDescriptionStencilLayout, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayoutBuilder<'_> {} +unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout {} +impl<'a> ::std::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> { + type Target = AttachmentDescriptionStencilLayout; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> { + #[inline] + pub fn stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self { + self.inner.stencil_initial_layout = stencil_initial_layout; + self + } + #[inline] + pub fn stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self { + self.inner.stencil_final_layout = stencil_final_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentDescriptionStencilLayout { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_executable_info: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_executable_info: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; +} +impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + #[inline] + pub fn pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self { + self.inner.pipeline_executable_info = pipeline_executable_info.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline: Pipeline, +} +impl ::std::default::Default for PipelineInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline: Pipeline::default(), + } + } +} +unsafe impl TaggedStructure for PipelineInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INFO_KHR; +} +impl PipelineInfoKHR { + pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> { + PipelineInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineInfoKHRBuilder<'a> { + inner: PipelineInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> { + type Target = PipelineInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineInfoKHRBuilder<'a> { + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.inner.pipeline = pipeline; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineExecutablePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stages: ShaderStageFlags, + pub name: [c_char; MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub subgroup_size: u32, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PipelineExecutablePropertiesKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PipelineExecutablePropertiesKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("stages", &self.stages) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("subgroup_size", &self.subgroup_size) + .finish() + } +} +impl ::std::default::Default for PipelineExecutablePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stages: ShaderStageFlags::default(), + name: unsafe { ::std::mem::zeroed() }, + description: unsafe { ::std::mem::zeroed() }, + subgroup_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineExecutablePropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR; +} +impl PipelineExecutablePropertiesKHR { + pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> { + PipelineExecutablePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineExecutablePropertiesKHRBuilder<'a> { + inner: PipelineExecutablePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> { + type Target = PipelineExecutablePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> { + #[inline] + pub fn stages(mut self, stages: ShaderStageFlags) -> Self { + self.inner.stages = stages; + self + } + #[inline] + pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.inner.subgroup_size = subgroup_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineExecutablePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineExecutableInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline: Pipeline, + pub executable_index: u32, +} +impl ::std::default::Default for PipelineExecutableInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline: Pipeline::default(), + executable_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineExecutableInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_INFO_KHR; +} +impl PipelineExecutableInfoKHR { + pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> { + PipelineExecutableInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineExecutableInfoKHRBuilder<'a> { + inner: PipelineExecutableInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> { + type Target = PipelineExecutableInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineExecutableInfoKHRBuilder<'a> { + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.inner.pipeline = pipeline; + self + } + #[inline] + pub fn executable_index(mut self, executable_index: u32) -> Self { + self.inner.executable_index = executable_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineExecutableInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union PipelineExecutableStatisticValueKHR { + pub b32: Bool32, + pub i64: i64, + pub u64: u64, + pub f64: f64, +} +impl ::std::default::Default for PipelineExecutableStatisticValueKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineExecutableStatisticKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub name: [c_char; MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub format: PipelineExecutableStatisticFormatKHR, + pub value: PipelineExecutableStatisticValueKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PipelineExecutableStatisticKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PipelineExecutableStatisticKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("format", &self.format) + .field("value", &"union") + .finish() + } +} +impl ::std::default::Default for PipelineExecutableStatisticKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + name: unsafe { ::std::mem::zeroed() }, + description: unsafe { ::std::mem::zeroed() }, + format: PipelineExecutableStatisticFormatKHR::default(), + value: PipelineExecutableStatisticValueKHR::default(), + } + } +} +unsafe impl TaggedStructure for PipelineExecutableStatisticKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR; +} +impl PipelineExecutableStatisticKHR { + pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> { + PipelineExecutableStatisticKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineExecutableStatisticKHRBuilder<'a> { + inner: PipelineExecutableStatisticKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> { + type Target = PipelineExecutableStatisticKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineExecutableStatisticKHRBuilder<'a> { + #[inline] + pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn format(mut self, format: PipelineExecutableStatisticFormatKHR) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self { + self.inner.value = value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineExecutableStatisticKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineExecutableInternalRepresentationKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub name: [c_char; MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub is_text: Bool32, + pub data_size: usize, + pub p_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PipelineExecutableInternalRepresentationKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PipelineExecutableInternalRepresentationKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("is_text", &self.is_text) + .field("data_size", &self.data_size) + .field("p_data", &self.p_data) + .finish() + } +} +impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + name: unsafe { ::std::mem::zeroed() }, + description: unsafe { ::std::mem::zeroed() }, + is_text: Bool32::default(), + data_size: usize::default(), + p_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for PipelineExecutableInternalRepresentationKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; +} +impl PipelineExecutableInternalRepresentationKHR { + pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> { + PipelineExecutableInternalRepresentationKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> { + inner: PipelineExecutableInternalRepresentationKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> { + type Target = PipelineExecutableInternalRepresentationKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> { + #[inline] + pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn is_text(mut self, is_text: bool) -> Self { + self.inner.is_text = is_text.into(); + self + } + #[inline] + pub fn data(mut self, data: &'a mut [u8]) -> Self { + self.inner.data_size = data.len(); + self.inner.p_data = data.as_mut_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineExecutableInternalRepresentationKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_demote_to_helper_invocation: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_demote_to_helper_invocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; +} +impl PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDemoteToHelperInvocationFeatures +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + #[inline] + pub fn shader_demote_to_helper_invocation( + mut self, + shader_demote_to_helper_invocation: bool, + ) -> Self { + self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub texel_buffer_alignment: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + texel_buffer_alignment: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; +} +impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + #[inline] + pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self { + self.inner.texel_buffer_alignment = texel_buffer_alignment.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTexelBufferAlignmentProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub storage_texel_buffer_offset_alignment_bytes: DeviceSize, + pub storage_texel_buffer_offset_single_texel_alignment: Bool32, + pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize, + pub uniform_texel_buffer_offset_single_texel_alignment: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(), + storage_texel_buffer_offset_single_texel_alignment: Bool32::default(), + uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(), + uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTexelBufferAlignmentProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; +} +impl PhysicalDeviceTexelBufferAlignmentProperties { + pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + PhysicalDeviceTexelBufferAlignmentPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + inner: PhysicalDeviceTexelBufferAlignmentProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + type Target = PhysicalDeviceTexelBufferAlignmentProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + #[inline] + pub fn storage_texel_buffer_offset_alignment_bytes( + mut self, + storage_texel_buffer_offset_alignment_bytes: DeviceSize, + ) -> Self { + self.inner.storage_texel_buffer_offset_alignment_bytes = + storage_texel_buffer_offset_alignment_bytes; + self + } + #[inline] + pub fn storage_texel_buffer_offset_single_texel_alignment( + mut self, + storage_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.inner + .storage_texel_buffer_offset_single_texel_alignment = + storage_texel_buffer_offset_single_texel_alignment.into(); + self + } + #[inline] + pub fn uniform_texel_buffer_offset_alignment_bytes( + mut self, + uniform_texel_buffer_offset_alignment_bytes: DeviceSize, + ) -> Self { + self.inner.uniform_texel_buffer_offset_alignment_bytes = + uniform_texel_buffer_offset_alignment_bytes; + self + } + #[inline] + pub fn uniform_texel_buffer_offset_single_texel_alignment( + mut self, + uniform_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.inner + .uniform_texel_buffer_offset_single_texel_alignment = + uniform_texel_buffer_offset_single_texel_alignment.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubgroupSizeControlFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subgroup_size_control: Bool32, + pub compute_full_subgroups: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subgroup_size_control: Bool32::default(), + compute_full_subgroups: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubgroupSizeControlFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; +} +impl PhysicalDeviceSubgroupSizeControlFeatures { + pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + PhysicalDeviceSubgroupSizeControlFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + inner: PhysicalDeviceSubgroupSizeControlFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + type Target = PhysicalDeviceSubgroupSizeControlFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + #[inline] + pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self { + self.inner.subgroup_size_control = subgroup_size_control.into(); + self + } + #[inline] + pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self { + self.inner.compute_full_subgroups = compute_full_subgroups.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubgroupSizeControlProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_subgroup_size: u32, + pub max_subgroup_size: u32, + pub max_compute_workgroup_subgroups: u32, + pub required_subgroup_size_stages: ShaderStageFlags, +} +impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_subgroup_size: u32::default(), + max_subgroup_size: u32::default(), + max_compute_workgroup_subgroups: u32::default(), + required_subgroup_size_stages: ShaderStageFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubgroupSizeControlProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; +} +impl PhysicalDeviceSubgroupSizeControlProperties { + pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + PhysicalDeviceSubgroupSizeControlPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + inner: PhysicalDeviceSubgroupSizeControlProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + type Target = PhysicalDeviceSubgroupSizeControlProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + #[inline] + pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self { + self.inner.min_subgroup_size = min_subgroup_size; + self + } + #[inline] + pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self { + self.inner.max_subgroup_size = max_subgroup_size; + self + } + #[inline] + pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self { + self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; + self + } + #[inline] + pub fn required_subgroup_size_stages( + mut self, + required_subgroup_size_stages: ShaderStageFlags, + ) -> Self { + self.inner.required_subgroup_size_stages = required_subgroup_size_stages; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubgroupSizeControlProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub required_subgroup_size: u32, +} +impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + required_subgroup_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineShaderStageRequiredSubgroupSizeCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; +} +impl PipelineShaderStageRequiredSubgroupSizeCreateInfo { + pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageRequiredSubgroupSizeCreateInfo +{ +} +impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + #[inline] + pub fn required_subgroup_size(mut self, required_subgroup_size: u32) -> Self { + self.inner.required_subgroup_size = required_subgroup_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassShadingPipelineCreateInfoHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub render_pass: RenderPass, + pub subpass: u32, +} +impl ::std::default::Default for SubpassShadingPipelineCreateInfoHUAWEI { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + render_pass: RenderPass::default(), + subpass: u32::default(), + } + } +} +unsafe impl TaggedStructure for SubpassShadingPipelineCreateInfoHUAWEI { + const STRUCTURE_TYPE: StructureType = + StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; +} +impl SubpassShadingPipelineCreateInfoHUAWEI { + pub fn builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + SubpassShadingPipelineCreateInfoHUAWEIBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + inner: SubpassShadingPipelineCreateInfoHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEI {} +impl<'a> ::std::ops::Deref for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + type Target = SubpassShadingPipelineCreateInfoHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn subpass(mut self, subpass: u32) -> Self { + self.inner.subpass = subpass; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassShadingPipelineCreateInfoHUAWEI { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_subpass_shading_workgroup_size_aspect_ratio: u32, +} +impl ::std::default::Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_subpass_shading_workgroup_size_aspect_ratio: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubpassShadingPropertiesHUAWEI { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; +} +impl PhysicalDeviceSubpassShadingPropertiesHUAWEI { + pub fn builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubpassShadingPropertiesHUAWEI {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + type Target = PhysicalDeviceSubpassShadingPropertiesHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + #[inline] + pub fn max_subpass_shading_workgroup_size_aspect_ratio( + mut self, + max_subpass_shading_workgroup_size_aspect_ratio: u32, + ) -> Self { + self.inner.max_subpass_shading_workgroup_size_aspect_ratio = + max_subpass_shading_workgroup_size_aspect_ratio; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubpassShadingPropertiesHUAWEI { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryOpaqueCaptureAddressAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub opaque_capture_address: u64, +} +impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + opaque_capture_address: u64::default(), + } + } +} +unsafe impl TaggedStructure for MemoryOpaqueCaptureAddressAllocateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; +} +impl MemoryOpaqueCaptureAddressAllocateInfo { + pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + MemoryOpaqueCaptureAddressAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + inner: MemoryOpaqueCaptureAddressAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo {} +impl<'a> ::std::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + type Target = MemoryOpaqueCaptureAddressAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + #[inline] + pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self { + self.inner.opaque_capture_address = opaque_capture_address; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryOpaqueCaptureAddressAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceMemoryOpaqueCaptureAddressInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, +} +impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + } + } +} +unsafe impl TaggedStructure for DeviceMemoryOpaqueCaptureAddressInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; +} +impl DeviceMemoryOpaqueCaptureAddressInfo { + pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + DeviceMemoryOpaqueCaptureAddressInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + inner: DeviceMemoryOpaqueCaptureAddressInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + type Target = DeviceMemoryOpaqueCaptureAddressInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceMemoryOpaqueCaptureAddressInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLineRasterizationFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub rectangular_lines: Bool32, + pub bresenham_lines: Bool32, + pub smooth_lines: Bool32, + pub stippled_rectangular_lines: Bool32, + pub stippled_bresenham_lines: Bool32, + pub stippled_smooth_lines: Bool32, +} +impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + rectangular_lines: Bool32::default(), + bresenham_lines: Bool32::default(), + smooth_lines: Bool32::default(), + stippled_rectangular_lines: Bool32::default(), + stippled_bresenham_lines: Bool32::default(), + stippled_smooth_lines: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceLineRasterizationFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT; +} +impl PhysicalDeviceLineRasterizationFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + PhysicalDeviceLineRasterizationFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceLineRasterizationFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceLineRasterizationFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + #[inline] + pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self { + self.inner.rectangular_lines = rectangular_lines.into(); + self + } + #[inline] + pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self { + self.inner.bresenham_lines = bresenham_lines.into(); + self + } + #[inline] + pub fn smooth_lines(mut self, smooth_lines: bool) -> Self { + self.inner.smooth_lines = smooth_lines.into(); + self + } + #[inline] + pub fn stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self { + self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into(); + self + } + #[inline] + pub fn stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self { + self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into(); + self + } + #[inline] + pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self { + self.inner.stippled_smooth_lines = stippled_smooth_lines.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLineRasterizationPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub line_sub_pixel_precision_bits: u32, +} +impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + line_sub_pixel_precision_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceLineRasterizationPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT; +} +impl PhysicalDeviceLineRasterizationPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + PhysicalDeviceLineRasterizationPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceLineRasterizationPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceLineRasterizationPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + #[inline] + pub fn line_sub_pixel_precision_bits(mut self, line_sub_pixel_precision_bits: u32) -> Self { + self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationLineStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub line_rasterization_mode: LineRasterizationModeEXT, + pub stippled_line_enable: Bool32, + pub line_stipple_factor: u32, + pub line_stipple_pattern: u16, +} +impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + line_rasterization_mode: LineRasterizationModeEXT::default(), + stippled_line_enable: Bool32::default(), + line_stipple_factor: u32::default(), + line_stipple_pattern: u16::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationLineStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT; +} +impl PipelineRasterizationLineStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationLineStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationLineStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationLineStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationLineStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationLineStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn line_rasterization_mode( + mut self, + line_rasterization_mode: LineRasterizationModeEXT, + ) -> Self { + self.inner.line_rasterization_mode = line_rasterization_mode; + self + } + #[inline] + pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self { + self.inner.stippled_line_enable = stippled_line_enable.into(); + self + } + #[inline] + pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self { + self.inner.line_stipple_factor = line_stipple_factor; + self + } + #[inline] + pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self { + self.inner.line_stipple_pattern = line_stipple_pattern; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationLineStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineCreationCacheControlFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_creation_cache_control: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_creation_cache_control: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineCreationCacheControlFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; +} +impl PhysicalDevicePipelineCreationCacheControlFeatures { + pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + PhysicalDevicePipelineCreationCacheControlFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + inner: PhysicalDevicePipelineCreationCacheControlFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCreationCacheControlFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + type Target = PhysicalDevicePipelineCreationCacheControlFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + #[inline] + pub fn pipeline_creation_cache_control( + mut self, + pipeline_creation_cache_control: bool, + ) -> Self { + self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan11Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub storage_buffer16_bit_access: Bool32, + pub uniform_and_storage_buffer16_bit_access: Bool32, + pub storage_push_constant16: Bool32, + pub storage_input_output16: Bool32, + pub multiview: Bool32, + pub multiview_geometry_shader: Bool32, + pub multiview_tessellation_shader: Bool32, + pub variable_pointers_storage_buffer: Bool32, + pub variable_pointers: Bool32, + pub protected_memory: Bool32, + pub sampler_ycbcr_conversion: Bool32, + pub shader_draw_parameters: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVulkan11Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + storage_buffer16_bit_access: Bool32::default(), + uniform_and_storage_buffer16_bit_access: Bool32::default(), + storage_push_constant16: Bool32::default(), + storage_input_output16: Bool32::default(), + multiview: Bool32::default(), + multiview_geometry_shader: Bool32::default(), + multiview_tessellation_shader: Bool32::default(), + variable_pointers_storage_buffer: Bool32::default(), + variable_pointers: Bool32::default(), + protected_memory: Bool32::default(), + sampler_ycbcr_conversion: Bool32::default(), + shader_draw_parameters: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan11Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; +} +impl PhysicalDeviceVulkan11Features { + pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> { + PhysicalDeviceVulkan11FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> { + inner: PhysicalDeviceVulkan11Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> { + type Target = PhysicalDeviceVulkan11Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> { + #[inline] + pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self { + self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); + self + } + #[inline] + pub fn uniform_and_storage_buffer16_bit_access( + mut self, + uniform_and_storage_buffer16_bit_access: bool, + ) -> Self { + self.inner.uniform_and_storage_buffer16_bit_access = + uniform_and_storage_buffer16_bit_access.into(); + self + } + #[inline] + pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self { + self.inner.storage_push_constant16 = storage_push_constant16.into(); + self + } + #[inline] + pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self { + self.inner.storage_input_output16 = storage_input_output16.into(); + self + } + #[inline] + pub fn multiview(mut self, multiview: bool) -> Self { + self.inner.multiview = multiview.into(); + self + } + #[inline] + pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self { + self.inner.multiview_geometry_shader = multiview_geometry_shader.into(); + self + } + #[inline] + pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self { + self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into(); + self + } + #[inline] + pub fn variable_pointers_storage_buffer( + mut self, + variable_pointers_storage_buffer: bool, + ) -> Self { + self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into(); + self + } + #[inline] + pub fn variable_pointers(mut self, variable_pointers: bool) -> Self { + self.inner.variable_pointers = variable_pointers.into(); + self + } + #[inline] + pub fn protected_memory(mut self, protected_memory: bool) -> Self { + self.inner.protected_memory = protected_memory.into(); + self + } + #[inline] + pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self { + self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); + self + } + #[inline] + pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self { + self.inner.shader_draw_parameters = shader_draw_parameters.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan11Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan11Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_uuid: [u8; UUID_SIZE], + pub driver_uuid: [u8; UUID_SIZE], + pub device_luid: [u8; LUID_SIZE], + pub device_node_mask: u32, + pub device_luid_valid: Bool32, + pub subgroup_size: u32, + pub subgroup_supported_stages: ShaderStageFlags, + pub subgroup_supported_operations: SubgroupFeatureFlags, + pub subgroup_quad_operations_in_all_stages: Bool32, + pub point_clipping_behavior: PointClippingBehavior, + pub max_multiview_view_count: u32, + pub max_multiview_instance_index: u32, + pub protected_no_fault: Bool32, + pub max_per_set_descriptors: u32, + pub max_memory_allocation_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceVulkan11Properties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_uuid: unsafe { ::std::mem::zeroed() }, + driver_uuid: unsafe { ::std::mem::zeroed() }, + device_luid: unsafe { ::std::mem::zeroed() }, + device_node_mask: u32::default(), + device_luid_valid: Bool32::default(), + subgroup_size: u32::default(), + subgroup_supported_stages: ShaderStageFlags::default(), + subgroup_supported_operations: SubgroupFeatureFlags::default(), + subgroup_quad_operations_in_all_stages: Bool32::default(), + point_clipping_behavior: PointClippingBehavior::default(), + max_multiview_view_count: u32::default(), + max_multiview_instance_index: u32::default(), + protected_no_fault: Bool32::default(), + max_per_set_descriptors: u32::default(), + max_memory_allocation_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan11Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; +} +impl PhysicalDeviceVulkan11Properties { + pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> { + PhysicalDeviceVulkan11PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> { + inner: PhysicalDeviceVulkan11Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> { + type Target = PhysicalDeviceVulkan11Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> { + #[inline] + pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.device_uuid = device_uuid; + self + } + #[inline] + pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.driver_uuid = driver_uuid; + self + } + #[inline] + pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self { + self.inner.device_luid = device_luid; + self + } + #[inline] + pub fn device_node_mask(mut self, device_node_mask: u32) -> Self { + self.inner.device_node_mask = device_node_mask; + self + } + #[inline] + pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self { + self.inner.device_luid_valid = device_luid_valid.into(); + self + } + #[inline] + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.inner.subgroup_size = subgroup_size; + self + } + #[inline] + pub fn subgroup_supported_stages( + mut self, + subgroup_supported_stages: ShaderStageFlags, + ) -> Self { + self.inner.subgroup_supported_stages = subgroup_supported_stages; + self + } + #[inline] + pub fn subgroup_supported_operations( + mut self, + subgroup_supported_operations: SubgroupFeatureFlags, + ) -> Self { + self.inner.subgroup_supported_operations = subgroup_supported_operations; + self + } + #[inline] + pub fn subgroup_quad_operations_in_all_stages( + mut self, + subgroup_quad_operations_in_all_stages: bool, + ) -> Self { + self.inner.subgroup_quad_operations_in_all_stages = + subgroup_quad_operations_in_all_stages.into(); + self + } + #[inline] + pub fn point_clipping_behavior( + mut self, + point_clipping_behavior: PointClippingBehavior, + ) -> Self { + self.inner.point_clipping_behavior = point_clipping_behavior; + self + } + #[inline] + pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self { + self.inner.max_multiview_view_count = max_multiview_view_count; + self + } + #[inline] + pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self { + self.inner.max_multiview_instance_index = max_multiview_instance_index; + self + } + #[inline] + pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self { + self.inner.protected_no_fault = protected_no_fault.into(); + self + } + #[inline] + pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self { + self.inner.max_per_set_descriptors = max_per_set_descriptors; + self + } + #[inline] + pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self { + self.inner.max_memory_allocation_size = max_memory_allocation_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan11Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan12Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sampler_mirror_clamp_to_edge: Bool32, + pub draw_indirect_count: Bool32, + pub storage_buffer8_bit_access: Bool32, + pub uniform_and_storage_buffer8_bit_access: Bool32, + pub storage_push_constant8: Bool32, + pub shader_buffer_int64_atomics: Bool32, + pub shader_shared_int64_atomics: Bool32, + pub shader_float16: Bool32, + pub shader_int8: Bool32, + pub descriptor_indexing: Bool32, + pub shader_input_attachment_array_dynamic_indexing: Bool32, + pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_uniform_buffer_array_non_uniform_indexing: Bool32, + pub shader_sampled_image_array_non_uniform_indexing: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_image_array_non_uniform_indexing: Bool32, + pub shader_input_attachment_array_non_uniform_indexing: Bool32, + pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32, + pub descriptor_binding_uniform_buffer_update_after_bind: Bool32, + pub descriptor_binding_sampled_image_update_after_bind: Bool32, + pub descriptor_binding_storage_image_update_after_bind: Bool32, + pub descriptor_binding_storage_buffer_update_after_bind: Bool32, + pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_update_unused_while_pending: Bool32, + pub descriptor_binding_partially_bound: Bool32, + pub descriptor_binding_variable_descriptor_count: Bool32, + pub runtime_descriptor_array: Bool32, + pub sampler_filter_minmax: Bool32, + pub scalar_block_layout: Bool32, + pub imageless_framebuffer: Bool32, + pub uniform_buffer_standard_layout: Bool32, + pub shader_subgroup_extended_types: Bool32, + pub separate_depth_stencil_layouts: Bool32, + pub host_query_reset: Bool32, + pub timeline_semaphore: Bool32, + pub buffer_device_address: Bool32, + pub buffer_device_address_capture_replay: Bool32, + pub buffer_device_address_multi_device: Bool32, + pub vulkan_memory_model: Bool32, + pub vulkan_memory_model_device_scope: Bool32, + pub vulkan_memory_model_availability_visibility_chains: Bool32, + pub shader_output_viewport_index: Bool32, + pub shader_output_layer: Bool32, + pub subgroup_broadcast_dynamic_id: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVulkan12Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + sampler_mirror_clamp_to_edge: Bool32::default(), + draw_indirect_count: Bool32::default(), + storage_buffer8_bit_access: Bool32::default(), + uniform_and_storage_buffer8_bit_access: Bool32::default(), + storage_push_constant8: Bool32::default(), + shader_buffer_int64_atomics: Bool32::default(), + shader_shared_int64_atomics: Bool32::default(), + shader_float16: Bool32::default(), + shader_int8: Bool32::default(), + descriptor_indexing: Bool32::default(), + shader_input_attachment_array_dynamic_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_image_array_non_uniform_indexing: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(), + descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(), + descriptor_binding_sampled_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_buffer_update_after_bind: Bool32::default(), + descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_update_unused_while_pending: Bool32::default(), + descriptor_binding_partially_bound: Bool32::default(), + descriptor_binding_variable_descriptor_count: Bool32::default(), + runtime_descriptor_array: Bool32::default(), + sampler_filter_minmax: Bool32::default(), + scalar_block_layout: Bool32::default(), + imageless_framebuffer: Bool32::default(), + uniform_buffer_standard_layout: Bool32::default(), + shader_subgroup_extended_types: Bool32::default(), + separate_depth_stencil_layouts: Bool32::default(), + host_query_reset: Bool32::default(), + timeline_semaphore: Bool32::default(), + buffer_device_address: Bool32::default(), + buffer_device_address_capture_replay: Bool32::default(), + buffer_device_address_multi_device: Bool32::default(), + vulkan_memory_model: Bool32::default(), + vulkan_memory_model_device_scope: Bool32::default(), + vulkan_memory_model_availability_visibility_chains: Bool32::default(), + shader_output_viewport_index: Bool32::default(), + shader_output_layer: Bool32::default(), + subgroup_broadcast_dynamic_id: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan12Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; +} +impl PhysicalDeviceVulkan12Features { + pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> { + PhysicalDeviceVulkan12FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> { + inner: PhysicalDeviceVulkan12Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> { + type Target = PhysicalDeviceVulkan12Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> { + #[inline] + pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self { + self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into(); + self + } + #[inline] + pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self { + self.inner.draw_indirect_count = draw_indirect_count.into(); + self + } + #[inline] + pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self { + self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); + self + } + #[inline] + pub fn uniform_and_storage_buffer8_bit_access( + mut self, + uniform_and_storage_buffer8_bit_access: bool, + ) -> Self { + self.inner.uniform_and_storage_buffer8_bit_access = + uniform_and_storage_buffer8_bit_access.into(); + self + } + #[inline] + pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self { + self.inner.storage_push_constant8 = storage_push_constant8.into(); + self + } + #[inline] + pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self { + self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); + self + } + #[inline] + pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self { + self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); + self + } + #[inline] + pub fn shader_float16(mut self, shader_float16: bool) -> Self { + self.inner.shader_float16 = shader_float16.into(); + self + } + #[inline] + pub fn shader_int8(mut self, shader_int8: bool) -> Self { + self.inner.shader_int8 = shader_int8.into(); + self + } + #[inline] + pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self { + self.inner.descriptor_indexing = descriptor_indexing.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_dynamic_indexing( + mut self, + shader_input_attachment_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_input_attachment_array_dynamic_indexing = + shader_input_attachment_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_texel_buffer_array_dynamic_indexing( + mut self, + shader_uniform_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner + .shader_uniform_texel_buffer_array_dynamic_indexing = + shader_uniform_texel_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_storage_texel_buffer_array_dynamic_indexing( + mut self, + shader_storage_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner + .shader_storage_texel_buffer_array_dynamic_indexing = + shader_storage_texel_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_uniform_buffer_array_non_uniform_indexing = + shader_uniform_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_non_uniform_indexing( + mut self, + shader_sampled_image_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_sampled_image_array_non_uniform_indexing = + shader_sampled_image_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_non_uniform_indexing( + mut self, + shader_storage_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_storage_buffer_array_non_uniform_indexing = + shader_storage_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_image_array_non_uniform_indexing( + mut self, + shader_storage_image_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_storage_image_array_non_uniform_indexing = + shader_storage_image_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_non_uniform_indexing( + mut self, + shader_input_attachment_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_input_attachment_array_non_uniform_indexing = + shader_input_attachment_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_uniform_texel_buffer_array_non_uniform_indexing = + shader_uniform_texel_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_texel_buffer_array_non_uniform_indexing( + mut self, + shader_storage_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_storage_texel_buffer_array_non_uniform_indexing = + shader_storage_texel_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn descriptor_binding_uniform_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_uniform_buffer_update_after_bind = + descriptor_binding_uniform_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_sampled_image_update_after_bind( + mut self, + descriptor_binding_sampled_image_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_sampled_image_update_after_bind = + descriptor_binding_sampled_image_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_image_update_after_bind( + mut self, + descriptor_binding_storage_image_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_image_update_after_bind = + descriptor_binding_storage_image_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_buffer_update_after_bind( + mut self, + descriptor_binding_storage_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_buffer_update_after_bind = + descriptor_binding_storage_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_texel_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_uniform_texel_buffer_update_after_bind = + descriptor_binding_uniform_texel_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_texel_buffer_update_after_bind( + mut self, + descriptor_binding_storage_texel_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_texel_buffer_update_after_bind = + descriptor_binding_storage_texel_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_update_unused_while_pending( + mut self, + descriptor_binding_update_unused_while_pending: bool, + ) -> Self { + self.inner.descriptor_binding_update_unused_while_pending = + descriptor_binding_update_unused_while_pending.into(); + self + } + #[inline] + pub fn descriptor_binding_partially_bound( + mut self, + descriptor_binding_partially_bound: bool, + ) -> Self { + self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into(); + self + } + #[inline] + pub fn descriptor_binding_variable_descriptor_count( + mut self, + descriptor_binding_variable_descriptor_count: bool, + ) -> Self { + self.inner.descriptor_binding_variable_descriptor_count = + descriptor_binding_variable_descriptor_count.into(); + self + } + #[inline] + pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self { + self.inner.runtime_descriptor_array = runtime_descriptor_array.into(); + self + } + #[inline] + pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self { + self.inner.sampler_filter_minmax = sampler_filter_minmax.into(); + self + } + #[inline] + pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self { + self.inner.scalar_block_layout = scalar_block_layout.into(); + self + } + #[inline] + pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self { + self.inner.imageless_framebuffer = imageless_framebuffer.into(); + self + } + #[inline] + pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self { + self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); + self + } + #[inline] + pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self { + self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); + self + } + #[inline] + pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self { + self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); + self + } + #[inline] + pub fn host_query_reset(mut self, host_query_reset: bool) -> Self { + self.inner.host_query_reset = host_query_reset.into(); + self + } + #[inline] + pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self { + self.inner.timeline_semaphore = timeline_semaphore.into(); + self + } + #[inline] + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.inner.buffer_device_address = buffer_device_address.into(); + self + } + #[inline] + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.inner.buffer_device_address_capture_replay = + buffer_device_address_capture_replay.into(); + self + } + #[inline] + pub fn buffer_device_address_multi_device( + mut self, + buffer_device_address_multi_device: bool, + ) -> Self { + self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self + } + #[inline] + pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self { + self.inner.vulkan_memory_model = vulkan_memory_model.into(); + self + } + #[inline] + pub fn vulkan_memory_model_device_scope( + mut self, + vulkan_memory_model_device_scope: bool, + ) -> Self { + self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); + self + } + #[inline] + pub fn vulkan_memory_model_availability_visibility_chains( + mut self, + vulkan_memory_model_availability_visibility_chains: bool, + ) -> Self { + self.inner + .vulkan_memory_model_availability_visibility_chains = + vulkan_memory_model_availability_visibility_chains.into(); + self + } + #[inline] + pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self { + self.inner.shader_output_viewport_index = shader_output_viewport_index.into(); + self + } + #[inline] + pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self { + self.inner.shader_output_layer = shader_output_layer.into(); + self + } + #[inline] + pub fn subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self { + self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan12Features { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan12Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub driver_id: DriverId, + pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE], + pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE], + pub conformance_version: ConformanceVersion, + pub denorm_behavior_independence: ShaderFloatControlsIndependence, + pub rounding_mode_independence: ShaderFloatControlsIndependence, + pub shader_signed_zero_inf_nan_preserve_float16: Bool32, + pub shader_signed_zero_inf_nan_preserve_float32: Bool32, + pub shader_signed_zero_inf_nan_preserve_float64: Bool32, + pub shader_denorm_preserve_float16: Bool32, + pub shader_denorm_preserve_float32: Bool32, + pub shader_denorm_preserve_float64: Bool32, + pub shader_denorm_flush_to_zero_float16: Bool32, + pub shader_denorm_flush_to_zero_float32: Bool32, + pub shader_denorm_flush_to_zero_float64: Bool32, + pub shader_rounding_mode_rte_float16: Bool32, + pub shader_rounding_mode_rte_float32: Bool32, + pub shader_rounding_mode_rte_float64: Bool32, + pub shader_rounding_mode_rtz_float16: Bool32, + pub shader_rounding_mode_rtz_float32: Bool32, + pub shader_rounding_mode_rtz_float64: Bool32, + pub max_update_after_bind_descriptors_in_all_pools: u32, + pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_sampled_image_array_non_uniform_indexing_native: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_storage_image_array_non_uniform_indexing_native: Bool32, + pub shader_input_attachment_array_non_uniform_indexing_native: Bool32, + pub robust_buffer_access_update_after_bind: Bool32, + pub quad_divergent_implicit_lod: Bool32, + pub max_per_stage_descriptor_update_after_bind_samplers: u32, + pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_sampled_images: u32, + pub max_per_stage_descriptor_update_after_bind_storage_images: u32, + pub max_per_stage_descriptor_update_after_bind_input_attachments: u32, + pub max_per_stage_update_after_bind_resources: u32, + pub max_descriptor_set_update_after_bind_samplers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_storage_buffers: u32, + pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_sampled_images: u32, + pub max_descriptor_set_update_after_bind_storage_images: u32, + pub max_descriptor_set_update_after_bind_input_attachments: u32, + pub supported_depth_resolve_modes: ResolveModeFlags, + pub supported_stencil_resolve_modes: ResolveModeFlags, + pub independent_resolve_none: Bool32, + pub independent_resolve: Bool32, + pub filter_minmax_single_component_formats: Bool32, + pub filter_minmax_image_component_mapping: Bool32, + pub max_timeline_semaphore_value_difference: u64, + pub framebuffer_integer_color_sample_counts: SampleCountFlags, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PhysicalDeviceVulkan12Properties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PhysicalDeviceVulkan12Properties") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("driver_id", &self.driver_id) + .field("driver_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr()) + }) + .field("driver_info", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr()) + }) + .field("conformance_version", &self.conformance_version) + .field( + "denorm_behavior_independence", + &self.denorm_behavior_independence, + ) + .field( + "rounding_mode_independence", + &self.rounding_mode_independence, + ) + .field( + "shader_signed_zero_inf_nan_preserve_float16", + &self.shader_signed_zero_inf_nan_preserve_float16, + ) + .field( + "shader_signed_zero_inf_nan_preserve_float32", + &self.shader_signed_zero_inf_nan_preserve_float32, + ) + .field( + "shader_signed_zero_inf_nan_preserve_float64", + &self.shader_signed_zero_inf_nan_preserve_float64, + ) + .field( + "shader_denorm_preserve_float16", + &self.shader_denorm_preserve_float16, + ) + .field( + "shader_denorm_preserve_float32", + &self.shader_denorm_preserve_float32, + ) + .field( + "shader_denorm_preserve_float64", + &self.shader_denorm_preserve_float64, + ) + .field( + "shader_denorm_flush_to_zero_float16", + &self.shader_denorm_flush_to_zero_float16, + ) + .field( + "shader_denorm_flush_to_zero_float32", + &self.shader_denorm_flush_to_zero_float32, + ) + .field( + "shader_denorm_flush_to_zero_float64", + &self.shader_denorm_flush_to_zero_float64, + ) + .field( + "shader_rounding_mode_rte_float16", + &self.shader_rounding_mode_rte_float16, + ) + .field( + "shader_rounding_mode_rte_float32", + &self.shader_rounding_mode_rte_float32, + ) + .field( + "shader_rounding_mode_rte_float64", + &self.shader_rounding_mode_rte_float64, + ) + .field( + "shader_rounding_mode_rtz_float16", + &self.shader_rounding_mode_rtz_float16, + ) + .field( + "shader_rounding_mode_rtz_float32", + &self.shader_rounding_mode_rtz_float32, + ) + .field( + "shader_rounding_mode_rtz_float64", + &self.shader_rounding_mode_rtz_float64, + ) + .field( + "max_update_after_bind_descriptors_in_all_pools", + &self.max_update_after_bind_descriptors_in_all_pools, + ) + .field( + "shader_uniform_buffer_array_non_uniform_indexing_native", + &self.shader_uniform_buffer_array_non_uniform_indexing_native, + ) + .field( + "shader_sampled_image_array_non_uniform_indexing_native", + &self.shader_sampled_image_array_non_uniform_indexing_native, + ) + .field( + "shader_storage_buffer_array_non_uniform_indexing_native", + &self.shader_storage_buffer_array_non_uniform_indexing_native, + ) + .field( + "shader_storage_image_array_non_uniform_indexing_native", + &self.shader_storage_image_array_non_uniform_indexing_native, + ) + .field( + "shader_input_attachment_array_non_uniform_indexing_native", + &self.shader_input_attachment_array_non_uniform_indexing_native, + ) + .field( + "robust_buffer_access_update_after_bind", + &self.robust_buffer_access_update_after_bind, + ) + .field( + "quad_divergent_implicit_lod", + &self.quad_divergent_implicit_lod, + ) + .field( + "max_per_stage_descriptor_update_after_bind_samplers", + &self.max_per_stage_descriptor_update_after_bind_samplers, + ) + .field( + "max_per_stage_descriptor_update_after_bind_uniform_buffers", + &self.max_per_stage_descriptor_update_after_bind_uniform_buffers, + ) + .field( + "max_per_stage_descriptor_update_after_bind_storage_buffers", + &self.max_per_stage_descriptor_update_after_bind_storage_buffers, + ) + .field( + "max_per_stage_descriptor_update_after_bind_sampled_images", + &self.max_per_stage_descriptor_update_after_bind_sampled_images, + ) + .field( + "max_per_stage_descriptor_update_after_bind_storage_images", + &self.max_per_stage_descriptor_update_after_bind_storage_images, + ) + .field( + "max_per_stage_descriptor_update_after_bind_input_attachments", + &self.max_per_stage_descriptor_update_after_bind_input_attachments, + ) + .field( + "max_per_stage_update_after_bind_resources", + &self.max_per_stage_update_after_bind_resources, + ) + .field( + "max_descriptor_set_update_after_bind_samplers", + &self.max_descriptor_set_update_after_bind_samplers, + ) + .field( + "max_descriptor_set_update_after_bind_uniform_buffers", + &self.max_descriptor_set_update_after_bind_uniform_buffers, + ) + .field( + "max_descriptor_set_update_after_bind_uniform_buffers_dynamic", + &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic, + ) + .field( + "max_descriptor_set_update_after_bind_storage_buffers", + &self.max_descriptor_set_update_after_bind_storage_buffers, + ) + .field( + "max_descriptor_set_update_after_bind_storage_buffers_dynamic", + &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic, + ) + .field( + "max_descriptor_set_update_after_bind_sampled_images", + &self.max_descriptor_set_update_after_bind_sampled_images, + ) + .field( + "max_descriptor_set_update_after_bind_storage_images", + &self.max_descriptor_set_update_after_bind_storage_images, + ) + .field( + "max_descriptor_set_update_after_bind_input_attachments", + &self.max_descriptor_set_update_after_bind_input_attachments, + ) + .field( + "supported_depth_resolve_modes", + &self.supported_depth_resolve_modes, + ) + .field( + "supported_stencil_resolve_modes", + &self.supported_stencil_resolve_modes, + ) + .field("independent_resolve_none", &self.independent_resolve_none) + .field("independent_resolve", &self.independent_resolve) + .field( + "filter_minmax_single_component_formats", + &self.filter_minmax_single_component_formats, + ) + .field( + "filter_minmax_image_component_mapping", + &self.filter_minmax_image_component_mapping, + ) + .field( + "max_timeline_semaphore_value_difference", + &self.max_timeline_semaphore_value_difference, + ) + .field( + "framebuffer_integer_color_sample_counts", + &self.framebuffer_integer_color_sample_counts, + ) + .finish() + } +} +impl ::std::default::Default for PhysicalDeviceVulkan12Properties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + driver_id: DriverId::default(), + driver_name: unsafe { ::std::mem::zeroed() }, + driver_info: unsafe { ::std::mem::zeroed() }, + conformance_version: ConformanceVersion::default(), + denorm_behavior_independence: ShaderFloatControlsIndependence::default(), + rounding_mode_independence: ShaderFloatControlsIndependence::default(), + shader_signed_zero_inf_nan_preserve_float16: Bool32::default(), + shader_signed_zero_inf_nan_preserve_float32: Bool32::default(), + shader_signed_zero_inf_nan_preserve_float64: Bool32::default(), + shader_denorm_preserve_float16: Bool32::default(), + shader_denorm_preserve_float32: Bool32::default(), + shader_denorm_preserve_float64: Bool32::default(), + shader_denorm_flush_to_zero_float16: Bool32::default(), + shader_denorm_flush_to_zero_float32: Bool32::default(), + shader_denorm_flush_to_zero_float64: Bool32::default(), + shader_rounding_mode_rte_float16: Bool32::default(), + shader_rounding_mode_rte_float32: Bool32::default(), + shader_rounding_mode_rte_float64: Bool32::default(), + shader_rounding_mode_rtz_float16: Bool32::default(), + shader_rounding_mode_rtz_float32: Bool32::default(), + shader_rounding_mode_rtz_float64: Bool32::default(), + max_update_after_bind_descriptors_in_all_pools: u32::default(), + shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_image_array_non_uniform_indexing_native: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(), + robust_buffer_access_update_after_bind: Bool32::default(), + quad_divergent_implicit_lod: Bool32::default(), + max_per_stage_descriptor_update_after_bind_samplers: u32::default(), + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_images: u32::default(), + max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(), + max_per_stage_update_after_bind_resources: u32::default(), + max_descriptor_set_update_after_bind_samplers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_sampled_images: u32::default(), + max_descriptor_set_update_after_bind_storage_images: u32::default(), + max_descriptor_set_update_after_bind_input_attachments: u32::default(), + supported_depth_resolve_modes: ResolveModeFlags::default(), + supported_stencil_resolve_modes: ResolveModeFlags::default(), + independent_resolve_none: Bool32::default(), + independent_resolve: Bool32::default(), + filter_minmax_single_component_formats: Bool32::default(), + filter_minmax_image_component_mapping: Bool32::default(), + max_timeline_semaphore_value_difference: u64::default(), + framebuffer_integer_color_sample_counts: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan12Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; +} +impl PhysicalDeviceVulkan12Properties { + pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> { + PhysicalDeviceVulkan12PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> { + inner: PhysicalDeviceVulkan12Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> { + type Target = PhysicalDeviceVulkan12Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> { + #[inline] + pub fn driver_id(mut self, driver_id: DriverId) -> Self { + self.inner.driver_id = driver_id; + self + } + #[inline] + pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self { + self.inner.driver_name = driver_name; + self + } + #[inline] + pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self { + self.inner.driver_info = driver_info; + self + } + #[inline] + pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self { + self.inner.conformance_version = conformance_version; + self + } + #[inline] + pub fn denorm_behavior_independence( + mut self, + denorm_behavior_independence: ShaderFloatControlsIndependence, + ) -> Self { + self.inner.denorm_behavior_independence = denorm_behavior_independence; + self + } + #[inline] + pub fn rounding_mode_independence( + mut self, + rounding_mode_independence: ShaderFloatControlsIndependence, + ) -> Self { + self.inner.rounding_mode_independence = rounding_mode_independence; + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float16( + mut self, + shader_signed_zero_inf_nan_preserve_float16: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float16 = + shader_signed_zero_inf_nan_preserve_float16.into(); + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float32( + mut self, + shader_signed_zero_inf_nan_preserve_float32: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float32 = + shader_signed_zero_inf_nan_preserve_float32.into(); + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float64( + mut self, + shader_signed_zero_inf_nan_preserve_float64: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float64 = + shader_signed_zero_inf_nan_preserve_float64.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self { + self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self { + self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self { + self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float16( + mut self, + shader_denorm_flush_to_zero_float16: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float32( + mut self, + shader_denorm_flush_to_zero_float32: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float64( + mut self, + shader_denorm_flush_to_zero_float64: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float16( + mut self, + shader_rounding_mode_rte_float16: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float32( + mut self, + shader_rounding_mode_rte_float32: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float64( + mut self, + shader_rounding_mode_rte_float64: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float16( + mut self, + shader_rounding_mode_rtz_float16: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float32( + mut self, + shader_rounding_mode_rtz_float32: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float64( + mut self, + shader_rounding_mode_rtz_float64: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); + self + } + #[inline] + pub fn max_update_after_bind_descriptors_in_all_pools( + mut self, + max_update_after_bind_descriptors_in_all_pools: u32, + ) -> Self { + self.inner.max_update_after_bind_descriptors_in_all_pools = + max_update_after_bind_descriptors_in_all_pools; + self + } + #[inline] + pub fn shader_uniform_buffer_array_non_uniform_indexing_native( + mut self, + shader_uniform_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_uniform_buffer_array_non_uniform_indexing_native = + shader_uniform_buffer_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_non_uniform_indexing_native( + mut self, + shader_sampled_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_sampled_image_array_non_uniform_indexing_native = + shader_sampled_image_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_non_uniform_indexing_native( + mut self, + shader_storage_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_storage_buffer_array_non_uniform_indexing_native = + shader_storage_buffer_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_storage_image_array_non_uniform_indexing_native( + mut self, + shader_storage_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_storage_image_array_non_uniform_indexing_native = + shader_storage_image_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_non_uniform_indexing_native( + mut self, + shader_input_attachment_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_input_attachment_array_non_uniform_indexing_native = + shader_input_attachment_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn robust_buffer_access_update_after_bind( + mut self, + robust_buffer_access_update_after_bind: bool, + ) -> Self { + self.inner.robust_buffer_access_update_after_bind = + robust_buffer_access_update_after_bind.into(); + self + } + #[inline] + pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self { + self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_samplers( + mut self, + max_per_stage_descriptor_update_after_bind_samplers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_samplers = + max_per_stage_descriptor_update_after_bind_samplers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_uniform_buffers = + max_per_stage_descriptor_update_after_bind_uniform_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_buffers = + max_per_stage_descriptor_update_after_bind_storage_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_sampled_images( + mut self, + max_per_stage_descriptor_update_after_bind_sampled_images: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_sampled_images = + max_per_stage_descriptor_update_after_bind_sampled_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_storage_images( + mut self, + max_per_stage_descriptor_update_after_bind_storage_images: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_images = + max_per_stage_descriptor_update_after_bind_storage_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_input_attachments( + mut self, + max_per_stage_descriptor_update_after_bind_input_attachments: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_input_attachments = + max_per_stage_descriptor_update_after_bind_input_attachments; + self + } + #[inline] + pub fn max_per_stage_update_after_bind_resources( + mut self, + max_per_stage_update_after_bind_resources: u32, + ) -> Self { + self.inner.max_per_stage_update_after_bind_resources = + max_per_stage_update_after_bind_resources; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_samplers( + mut self, + max_descriptor_set_update_after_bind_samplers: u32, + ) -> Self { + self.inner.max_descriptor_set_update_after_bind_samplers = + max_descriptor_set_update_after_bind_samplers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_uniform_buffers( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers = + max_descriptor_set_update_after_bind_uniform_buffers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers_dynamic = + max_descriptor_set_update_after_bind_uniform_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_buffers( + mut self, + max_descriptor_set_update_after_bind_storage_buffers: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers = + max_descriptor_set_update_after_bind_storage_buffers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers_dynamic = + max_descriptor_set_update_after_bind_storage_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_sampled_images( + mut self, + max_descriptor_set_update_after_bind_sampled_images: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_sampled_images = + max_descriptor_set_update_after_bind_sampled_images; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_images( + mut self, + max_descriptor_set_update_after_bind_storage_images: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_images = + max_descriptor_set_update_after_bind_storage_images; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_input_attachments( + mut self, + max_descriptor_set_update_after_bind_input_attachments: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_input_attachments = + max_descriptor_set_update_after_bind_input_attachments; + self + } + #[inline] + pub fn supported_depth_resolve_modes( + mut self, + supported_depth_resolve_modes: ResolveModeFlags, + ) -> Self { + self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; + self + } + #[inline] + pub fn supported_stencil_resolve_modes( + mut self, + supported_stencil_resolve_modes: ResolveModeFlags, + ) -> Self { + self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self + } + #[inline] + pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self { + self.inner.independent_resolve_none = independent_resolve_none.into(); + self + } + #[inline] + pub fn independent_resolve(mut self, independent_resolve: bool) -> Self { + self.inner.independent_resolve = independent_resolve.into(); + self + } + #[inline] + pub fn filter_minmax_single_component_formats( + mut self, + filter_minmax_single_component_formats: bool, + ) -> Self { + self.inner.filter_minmax_single_component_formats = + filter_minmax_single_component_formats.into(); + self + } + #[inline] + pub fn filter_minmax_image_component_mapping( + mut self, + filter_minmax_image_component_mapping: bool, + ) -> Self { + self.inner.filter_minmax_image_component_mapping = + filter_minmax_image_component_mapping.into(); + self + } + #[inline] + pub fn max_timeline_semaphore_value_difference( + mut self, + max_timeline_semaphore_value_difference: u64, + ) -> Self { + self.inner.max_timeline_semaphore_value_difference = + max_timeline_semaphore_value_difference; + self + } + #[inline] + pub fn framebuffer_integer_color_sample_counts( + mut self, + framebuffer_integer_color_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_integer_color_sample_counts = + framebuffer_integer_color_sample_counts; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan12Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan13Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_image_access: Bool32, + pub inline_uniform_block: Bool32, + pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32, + pub pipeline_creation_cache_control: Bool32, + pub private_data: Bool32, + pub shader_demote_to_helper_invocation: Bool32, + pub shader_terminate_invocation: Bool32, + pub subgroup_size_control: Bool32, + pub compute_full_subgroups: Bool32, + pub synchronization2: Bool32, + pub texture_compression_astc_hdr: Bool32, + pub shader_zero_initialize_workgroup_memory: Bool32, + pub dynamic_rendering: Bool32, + pub shader_integer_dot_product: Bool32, + pub maintenance4: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVulkan13Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + robust_image_access: Bool32::default(), + inline_uniform_block: Bool32::default(), + descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(), + pipeline_creation_cache_control: Bool32::default(), + private_data: Bool32::default(), + shader_demote_to_helper_invocation: Bool32::default(), + shader_terminate_invocation: Bool32::default(), + subgroup_size_control: Bool32::default(), + compute_full_subgroups: Bool32::default(), + synchronization2: Bool32::default(), + texture_compression_astc_hdr: Bool32::default(), + shader_zero_initialize_workgroup_memory: Bool32::default(), + dynamic_rendering: Bool32::default(), + shader_integer_dot_product: Bool32::default(), + maintenance4: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan13Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; +} +impl PhysicalDeviceVulkan13Features { + pub fn builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a> { + PhysicalDeviceVulkan13FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan13FeaturesBuilder<'a> { + inner: PhysicalDeviceVulkan13Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13FeaturesBuilder<'a> { + type Target = PhysicalDeviceVulkan13Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan13FeaturesBuilder<'a> { + #[inline] + pub fn robust_image_access(mut self, robust_image_access: bool) -> Self { + self.inner.robust_image_access = robust_image_access.into(); + self + } + #[inline] + pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self { + self.inner.inline_uniform_block = inline_uniform_block.into(); + self + } + #[inline] + pub fn descriptor_binding_inline_uniform_block_update_after_bind( + mut self, + descriptor_binding_inline_uniform_block_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_inline_uniform_block_update_after_bind = + descriptor_binding_inline_uniform_block_update_after_bind.into(); + self + } + #[inline] + pub fn pipeline_creation_cache_control( + mut self, + pipeline_creation_cache_control: bool, + ) -> Self { + self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into(); + self + } + #[inline] + pub fn private_data(mut self, private_data: bool) -> Self { + self.inner.private_data = private_data.into(); + self + } + #[inline] + pub fn shader_demote_to_helper_invocation( + mut self, + shader_demote_to_helper_invocation: bool, + ) -> Self { + self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into(); + self + } + #[inline] + pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self { + self.inner.shader_terminate_invocation = shader_terminate_invocation.into(); + self + } + #[inline] + pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self { + self.inner.subgroup_size_control = subgroup_size_control.into(); + self + } + #[inline] + pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self { + self.inner.compute_full_subgroups = compute_full_subgroups.into(); + self + } + #[inline] + pub fn synchronization2(mut self, synchronization2: bool) -> Self { + self.inner.synchronization2 = synchronization2.into(); + self + } + #[inline] + pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self { + self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); + self + } + #[inline] + pub fn shader_zero_initialize_workgroup_memory( + mut self, + shader_zero_initialize_workgroup_memory: bool, + ) -> Self { + self.inner.shader_zero_initialize_workgroup_memory = + shader_zero_initialize_workgroup_memory.into(); + self + } + #[inline] + pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { + self.inner.dynamic_rendering = dynamic_rendering.into(); + self + } + #[inline] + pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self { + self.inner.shader_integer_dot_product = shader_integer_dot_product.into(); + self + } + #[inline] + pub fn maintenance4(mut self, maintenance4: bool) -> Self { + self.inner.maintenance4 = maintenance4.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan13Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan13Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_subgroup_size: u32, + pub max_subgroup_size: u32, + pub max_compute_workgroup_subgroups: u32, + pub required_subgroup_size_stages: ShaderStageFlags, + pub max_inline_uniform_block_size: u32, + pub max_per_stage_descriptor_inline_uniform_blocks: u32, + pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + pub max_descriptor_set_inline_uniform_blocks: u32, + pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + pub max_inline_uniform_total_size: u32, + pub integer_dot_product8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product8_bit_signed_accelerated: Bool32, + pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32, + pub integer_dot_product16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product16_bit_signed_accelerated: Bool32, + pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product32_bit_signed_accelerated: Bool32, + pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product64_bit_signed_accelerated: Bool32, + pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: + Bool32, + pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32, + pub storage_texel_buffer_offset_alignment_bytes: DeviceSize, + pub storage_texel_buffer_offset_single_texel_alignment: Bool32, + pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize, + pub uniform_texel_buffer_offset_single_texel_alignment: Bool32, + pub max_buffer_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceVulkan13Properties { + #[inline] + fn default() -> Self { + Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , min_subgroup_size : u32 :: default () , max_subgroup_size : u32 :: default () , max_compute_workgroup_subgroups : u32 :: default () , required_subgroup_size_stages : ShaderStageFlags :: default () , max_inline_uniform_block_size : u32 :: default () , max_per_stage_descriptor_inline_uniform_blocks : u32 :: default () , max_per_stage_descriptor_update_after_bind_inline_uniform_blocks : u32 :: default () , max_descriptor_set_inline_uniform_blocks : u32 :: default () , max_descriptor_set_update_after_bind_inline_uniform_blocks : u32 :: default () , max_inline_uniform_total_size : u32 :: default () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , storage_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , storage_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , uniform_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , uniform_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , max_buffer_size : DeviceSize :: default () } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan13Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; +} +impl PhysicalDeviceVulkan13Properties { + pub fn builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a> { + PhysicalDeviceVulkan13PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan13PropertiesBuilder<'a> { + inner: PhysicalDeviceVulkan13Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13PropertiesBuilder<'a> { + type Target = PhysicalDeviceVulkan13Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan13PropertiesBuilder<'a> { + #[inline] + pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self { + self.inner.min_subgroup_size = min_subgroup_size; + self + } + #[inline] + pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self { + self.inner.max_subgroup_size = max_subgroup_size; + self + } + #[inline] + pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self { + self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; + self + } + #[inline] + pub fn required_subgroup_size_stages( + mut self, + required_subgroup_size_stages: ShaderStageFlags, + ) -> Self { + self.inner.required_subgroup_size_stages = required_subgroup_size_stages; + self + } + #[inline] + pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self { + self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size; + self + } + #[inline] + pub fn max_per_stage_descriptor_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_inline_uniform_blocks: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_inline_uniform_blocks = + max_per_stage_descriptor_inline_uniform_blocks; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks; + self + } + #[inline] + pub fn max_descriptor_set_inline_uniform_blocks( + mut self, + max_descriptor_set_inline_uniform_blocks: u32, + ) -> Self { + self.inner.max_descriptor_set_inline_uniform_blocks = + max_descriptor_set_inline_uniform_blocks; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks( + mut self, + max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_inline_uniform_blocks = + max_descriptor_set_update_after_bind_inline_uniform_blocks; + self + } + #[inline] + pub fn max_inline_uniform_total_size(mut self, max_inline_uniform_total_size: u32) -> Self { + self.inner.max_inline_uniform_total_size = max_inline_uniform_total_size; + self + } + #[inline] + pub fn integer_dot_product8_bit_unsigned_accelerated( + mut self, + integer_dot_product8_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product8_bit_unsigned_accelerated = + integer_dot_product8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_signed_accelerated( + mut self, + integer_dot_product8_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product8_bit_signed_accelerated = + integer_dot_product8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product8_bit_mixed_signedness_accelerated = + integer_dot_product8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_unsigned_accelerated = + integer_dot_product4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_signed_accelerated = + integer_dot_product4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_unsigned_accelerated( + mut self, + integer_dot_product16_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product16_bit_unsigned_accelerated = + integer_dot_product16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_signed_accelerated( + mut self, + integer_dot_product16_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product16_bit_signed_accelerated = + integer_dot_product16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product16_bit_mixed_signedness_accelerated = + integer_dot_product16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_unsigned_accelerated( + mut self, + integer_dot_product32_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product32_bit_unsigned_accelerated = + integer_dot_product32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_signed_accelerated( + mut self, + integer_dot_product32_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product32_bit_signed_accelerated = + integer_dot_product32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product32_bit_mixed_signedness_accelerated = + integer_dot_product32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_unsigned_accelerated( + mut self, + integer_dot_product64_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product64_bit_unsigned_accelerated = + integer_dot_product64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_signed_accelerated( + mut self, + integer_dot_product64_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product64_bit_signed_accelerated = + integer_dot_product64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product64_bit_mixed_signedness_accelerated = + integer_dot_product64_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_signed_accelerated = + integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, + ) -> Self { + self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_signed_accelerated = + integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_signed_accelerated = + integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_signed_accelerated = + integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn storage_texel_buffer_offset_alignment_bytes( + mut self, + storage_texel_buffer_offset_alignment_bytes: DeviceSize, + ) -> Self { + self.inner.storage_texel_buffer_offset_alignment_bytes = + storage_texel_buffer_offset_alignment_bytes; + self + } + #[inline] + pub fn storage_texel_buffer_offset_single_texel_alignment( + mut self, + storage_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.inner + .storage_texel_buffer_offset_single_texel_alignment = + storage_texel_buffer_offset_single_texel_alignment.into(); + self + } + #[inline] + pub fn uniform_texel_buffer_offset_alignment_bytes( + mut self, + uniform_texel_buffer_offset_alignment_bytes: DeviceSize, + ) -> Self { + self.inner.uniform_texel_buffer_offset_alignment_bytes = + uniform_texel_buffer_offset_alignment_bytes; + self + } + #[inline] + pub fn uniform_texel_buffer_offset_single_texel_alignment( + mut self, + uniform_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.inner + .uniform_texel_buffer_offset_single_texel_alignment = + uniform_texel_buffer_offset_single_texel_alignment.into(); + self + } + #[inline] + pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self { + self.inner.max_buffer_size = max_buffer_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan13Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCompilerControlCreateInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub compiler_control_flags: PipelineCompilerControlFlagsAMD, +} +impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + compiler_control_flags: PipelineCompilerControlFlagsAMD::default(), + } + } +} +unsafe impl TaggedStructure for PipelineCompilerControlCreateInfoAMD { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; +} +impl PipelineCompilerControlCreateInfoAMD { + pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> { + PipelineCompilerControlCreateInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> { + inner: PipelineCompilerControlCreateInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {} +impl<'a> ::std::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> { + type Target = PipelineCompilerControlCreateInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> { + #[inline] + pub fn compiler_control_flags( + mut self, + compiler_control_flags: PipelineCompilerControlFlagsAMD, + ) -> Self { + self.inner.compiler_control_flags = compiler_control_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCompilerControlCreateInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCoherentMemoryFeaturesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_coherent_memory: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_coherent_memory: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCoherentMemoryFeaturesAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; +} +impl PhysicalDeviceCoherentMemoryFeaturesAMD { + pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + PhysicalDeviceCoherentMemoryFeaturesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + inner: PhysicalDeviceCoherentMemoryFeaturesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + type Target = PhysicalDeviceCoherentMemoryFeaturesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + #[inline] + pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self { + self.inner.device_coherent_memory = device_coherent_memory.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceToolProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub name: [c_char; MAX_EXTENSION_NAME_SIZE], + pub version: [c_char; MAX_EXTENSION_NAME_SIZE], + pub purposes: ToolPurposeFlags, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub layer: [c_char; MAX_EXTENSION_NAME_SIZE], +} +#[cfg(feature = "debug")] +impl fmt::Debug for PhysicalDeviceToolProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PhysicalDeviceToolProperties") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("version", &unsafe { + ::std::ffi::CStr::from_ptr(self.version.as_ptr()) + }) + .field("purposes", &self.purposes) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("layer", &unsafe { + ::std::ffi::CStr::from_ptr(self.layer.as_ptr()) + }) + .finish() + } +} +impl ::std::default::Default for PhysicalDeviceToolProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + name: unsafe { ::std::mem::zeroed() }, + version: unsafe { ::std::mem::zeroed() }, + purposes: ToolPurposeFlags::default(), + description: unsafe { ::std::mem::zeroed() }, + layer: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceToolProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES; +} +impl PhysicalDeviceToolProperties { + pub fn builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a> { + PhysicalDeviceToolPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceToolPropertiesBuilder<'a> { + inner: PhysicalDeviceToolProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesBuilder<'a> { + type Target = PhysicalDeviceToolProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceToolPropertiesBuilder<'a> { + #[inline] + pub fn name(mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn version(mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.version = version; + self + } + #[inline] + pub fn purposes(mut self, purposes: ToolPurposeFlags) -> Self { + self.inner.purposes = purposes; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn layer(mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.layer = layer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceToolProperties { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCustomBorderColorCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub custom_border_color: ClearColorValue, + pub format: Format, +} +#[cfg(feature = "debug")] +impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("custom_border_color", &"union") + .field("format", &self.format) + .finish() + } +} +impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + custom_border_color: ClearColorValue::default(), + format: Format::default(), + } + } +} +unsafe impl TaggedStructure for SamplerCustomBorderColorCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; +} +impl SamplerCustomBorderColorCreateInfoEXT { + pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + SamplerCustomBorderColorCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + inner: SamplerCustomBorderColorCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + type Target = SamplerCustomBorderColorCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + #[inline] + pub fn custom_border_color(mut self, custom_border_color: ClearColorValue) -> Self { + self.inner.custom_border_color = custom_border_color; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerCustomBorderColorCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCustomBorderColorPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_custom_border_color_samplers: u32, +} +impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_custom_border_color_samplers: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCustomBorderColorPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; +} +impl PhysicalDeviceCustomBorderColorPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + PhysicalDeviceCustomBorderColorPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceCustomBorderColorPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceCustomBorderColorPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_custom_border_color_samplers( + mut self, + max_custom_border_color_samplers: u32, + ) -> Self { + self.inner.max_custom_border_color_samplers = max_custom_border_color_samplers; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCustomBorderColorFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub custom_border_colors: Bool32, + pub custom_border_color_without_format: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + custom_border_colors: Bool32::default(), + custom_border_color_without_format: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCustomBorderColorFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; +} +impl PhysicalDeviceCustomBorderColorFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + PhysicalDeviceCustomBorderColorFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceCustomBorderColorFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceCustomBorderColorFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + #[inline] + pub fn custom_border_colors(mut self, custom_border_colors: bool) -> Self { + self.inner.custom_border_colors = custom_border_colors.into(); + self + } + #[inline] + pub fn custom_border_color_without_format( + mut self, + custom_border_color_without_format: bool, + ) -> Self { + self.inner.custom_border_color_without_format = custom_border_color_without_format.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerBorderColorComponentMappingCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub components: ComponentMapping, + pub srgb: Bool32, +} +impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + components: ComponentMapping::default(), + srgb: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SamplerBorderColorComponentMappingCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT; +} +impl SamplerBorderColorComponentMappingCreateInfoEXT { + pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + SamplerBorderColorComponentMappingCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + inner: SamplerBorderColorComponentMappingCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo + for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + type Target = SamplerBorderColorComponentMappingCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + #[inline] + pub fn components(mut self, components: ComponentMapping) -> Self { + self.inner.components = components; + self + } + #[inline] + pub fn srgb(mut self, srgb: bool) -> Self { + self.inner.srgb = srgb.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerBorderColorComponentMappingCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub border_color_swizzle: Bool32, + pub border_color_swizzle_from_image: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + border_color_swizzle: Bool32::default(), + border_color_swizzle_from_image: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBorderColorSwizzleFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; +} +impl PhysicalDeviceBorderColorSwizzleFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + #[inline] + pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self { + self.inner.border_color_swizzle = border_color_swizzle.into(); + self + } + #[inline] + pub fn border_color_swizzle_from_image( + mut self, + border_color_swizzle_from_image: bool, + ) -> Self { + self.inner.border_color_swizzle_from_image = border_color_swizzle_from_image.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union DeviceOrHostAddressKHR { + pub device_address: DeviceAddress, + pub host_address: *mut c_void, +} +impl ::std::default::Default for DeviceOrHostAddressKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union DeviceOrHostAddressConstKHR { + pub device_address: DeviceAddress, + pub host_address: *const c_void, +} +impl ::std::default::Default for DeviceOrHostAddressConstKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryTrianglesDataKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_format: Format, + pub vertex_data: DeviceOrHostAddressConstKHR, + pub vertex_stride: DeviceSize, + pub max_vertex: u32, + pub index_type: IndexType, + pub index_data: DeviceOrHostAddressConstKHR, + pub transform_data: DeviceOrHostAddressConstKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("vertex_format", &self.vertex_format) + .field("vertex_data", &"union") + .field("vertex_stride", &self.vertex_stride) + .field("max_vertex", &self.max_vertex) + .field("index_type", &self.index_type) + .field("index_data", &"union") + .field("transform_data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_format: Format::default(), + vertex_data: DeviceOrHostAddressConstKHR::default(), + vertex_stride: DeviceSize::default(), + max_vertex: u32::default(), + index_type: IndexType::default(), + index_data: DeviceOrHostAddressConstKHR::default(), + transform_data: DeviceOrHostAddressConstKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryTrianglesDataKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; +} +impl AccelerationStructureGeometryTrianglesDataKHR { + pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + AccelerationStructureGeometryTrianglesDataKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + inner: AccelerationStructureGeometryTrianglesDataKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + type Target = AccelerationStructureGeometryTrianglesDataKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + #[inline] + pub fn vertex_format(mut self, vertex_format: Format) -> Self { + self.inner.vertex_format = vertex_format; + self + } + #[inline] + pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.vertex_data = vertex_data; + self + } + #[inline] + pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self { + self.inner.vertex_stride = vertex_stride; + self + } + #[inline] + pub fn max_vertex(mut self, max_vertex: u32) -> Self { + self.inner.max_vertex = max_vertex; + self + } + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[inline] + pub fn index_data(mut self, index_data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.index_data = index_data; + self + } + #[inline] + pub fn transform_data(mut self, transform_data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.transform_data = transform_data; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryTrianglesDataKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryAabbsDataKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub data: DeviceOrHostAddressConstKHR, + pub stride: DeviceSize, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("data", &"union") + .field("stride", &self.stride) + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + data: DeviceOrHostAddressConstKHR::default(), + stride: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryAabbsDataKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; +} +impl AccelerationStructureGeometryAabbsDataKHR { + pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + AccelerationStructureGeometryAabbsDataKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + inner: AccelerationStructureGeometryAabbsDataKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + type Target = AccelerationStructureGeometryAabbsDataKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + #[inline] + pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.data = data; + self + } + #[inline] + pub fn stride(mut self, stride: DeviceSize) -> Self { + self.inner.stride = stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryAabbsDataKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryInstancesDataKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub array_of_pointers: Bool32, + pub data: DeviceOrHostAddressConstKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("array_of_pointers", &self.array_of_pointers) + .field("data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + array_of_pointers: Bool32::default(), + data: DeviceOrHostAddressConstKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryInstancesDataKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; +} +impl AccelerationStructureGeometryInstancesDataKHR { + pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + AccelerationStructureGeometryInstancesDataKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + inner: AccelerationStructureGeometryInstancesDataKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + type Target = AccelerationStructureGeometryInstancesDataKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + #[inline] + pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self { + self.inner.array_of_pointers = array_of_pointers.into(); + self + } + #[inline] + pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryInstancesDataKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union AccelerationStructureGeometryDataKHR { + pub triangles: AccelerationStructureGeometryTrianglesDataKHR, + pub aabbs: AccelerationStructureGeometryAabbsDataKHR, + pub instances: AccelerationStructureGeometryInstancesDataKHR, +} +impl ::std::default::Default for AccelerationStructureGeometryDataKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub geometry_type: GeometryTypeKHR, + pub geometry: AccelerationStructureGeometryDataKHR, + pub flags: GeometryFlagsKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("geometry_type", &self.geometry_type) + .field("geometry", &"union") + .field("flags", &self.flags) + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + geometry_type: GeometryTypeKHR::default(), + geometry: AccelerationStructureGeometryDataKHR::default(), + flags: GeometryFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR; +} +impl AccelerationStructureGeometryKHR { + pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> { + AccelerationStructureGeometryKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryKHRBuilder<'a> { + inner: AccelerationStructureGeometryKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> { + type Target = AccelerationStructureGeometryKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryKHRBuilder<'a> { + #[inline] + pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self { + self.inner.geometry_type = geometry_type; + self + } + #[inline] + pub fn geometry(mut self, geometry: AccelerationStructureGeometryDataKHR) -> Self { + self.inner.geometry = geometry; + self + } + #[inline] + pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureBuildGeometryInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: AccelerationStructureTypeKHR, + pub flags: BuildAccelerationStructureFlagsKHR, + pub mode: BuildAccelerationStructureModeKHR, + pub src_acceleration_structure: AccelerationStructureKHR, + pub dst_acceleration_structure: AccelerationStructureKHR, + pub geometry_count: u32, + pub p_geometries: *const AccelerationStructureGeometryKHR, + pub pp_geometries: *const *const AccelerationStructureGeometryKHR, + pub scratch_data: DeviceOrHostAddressKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("flags", &self.flags) + .field("mode", &self.mode) + .field( + "src_acceleration_structure", + &self.src_acceleration_structure, + ) + .field( + "dst_acceleration_structure", + &self.dst_acceleration_structure, + ) + .field("geometry_count", &self.geometry_count) + .field("p_geometries", &self.p_geometries) + .field("pp_geometries", &self.pp_geometries) + .field("scratch_data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: AccelerationStructureTypeKHR::default(), + flags: BuildAccelerationStructureFlagsKHR::default(), + mode: BuildAccelerationStructureModeKHR::default(), + src_acceleration_structure: AccelerationStructureKHR::default(), + dst_acceleration_structure: AccelerationStructureKHR::default(), + geometry_count: u32::default(), + p_geometries: ::std::ptr::null(), + pp_geometries: ::std::ptr::null(), + scratch_data: DeviceOrHostAddressKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureBuildGeometryInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR; +} +impl AccelerationStructureBuildGeometryInfoKHR { + pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + AccelerationStructureBuildGeometryInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + inner: AccelerationStructureBuildGeometryInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + type Target = AccelerationStructureBuildGeometryInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: BuildAccelerationStructureFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn mode(mut self, mode: BuildAccelerationStructureModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[inline] + pub fn src_acceleration_structure( + mut self, + src_acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.inner.src_acceleration_structure = src_acceleration_structure; + self + } + #[inline] + pub fn dst_acceleration_structure( + mut self, + dst_acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.inner.dst_acceleration_structure = dst_acceleration_structure; + self + } + #[inline] + pub fn geometries(mut self, geometries: &'a [AccelerationStructureGeometryKHR]) -> Self { + self.inner.geometry_count = geometries.len() as _; + self.inner.p_geometries = geometries.as_ptr(); + self + } + #[inline] + pub fn geometries_ptrs( + mut self, + geometries_ptrs: &'a [&'a AccelerationStructureGeometryKHR], + ) -> Self { + self.inner.geometry_count = geometries_ptrs.len() as _; + self.inner.pp_geometries = geometries_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self { + self.inner.scratch_data = scratch_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureBuildGeometryInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AccelerationStructureBuildRangeInfoKHR { + pub primitive_count: u32, + pub primitive_offset: u32, + pub first_vertex: u32, + pub transform_offset: u32, +} +impl AccelerationStructureBuildRangeInfoKHR { + pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + AccelerationStructureBuildRangeInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + inner: AccelerationStructureBuildRangeInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + type Target = AccelerationStructureBuildRangeInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + #[inline] + pub fn primitive_count(mut self, primitive_count: u32) -> Self { + self.inner.primitive_count = primitive_count; + self + } + #[inline] + pub fn primitive_offset(mut self, primitive_offset: u32) -> Self { + self.inner.primitive_offset = primitive_offset; + self + } + #[inline] + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.inner.first_vertex = first_vertex; + self + } + #[inline] + pub fn transform_offset(mut self, transform_offset: u32) -> Self { + self.inner.transform_offset = transform_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureBuildRangeInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_flags: AccelerationStructureCreateFlagsKHR, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, + pub ty: AccelerationStructureTypeKHR, + pub device_address: DeviceAddress, +} +impl ::std::default::Default for AccelerationStructureCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + create_flags: AccelerationStructureCreateFlagsKHR::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + ty: AccelerationStructureTypeKHR::default(), + device_address: DeviceAddress::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR; +} +impl AccelerationStructureCreateInfoKHR { + pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> { + AccelerationStructureCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureCreateInfoKHRBuilder<'a> { + inner: AccelerationStructureCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {} +impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> { + type Target = AccelerationStructureCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> { + #[inline] + pub fn create_flags(mut self, create_flags: AccelerationStructureCreateFlagsKHR) -> Self { + self.inner.create_flags = create_flags; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AabbPositionsKHR { + pub min_x: f32, + pub min_y: f32, + pub min_z: f32, + pub max_x: f32, + pub max_y: f32, + pub max_z: f32, +} +impl AabbPositionsKHR { + pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> { + AabbPositionsKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AabbPositionsKHRBuilder<'a> { + inner: AabbPositionsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> { + type Target = AabbPositionsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AabbPositionsKHRBuilder<'a> { + #[inline] + pub fn min_x(mut self, min_x: f32) -> Self { + self.inner.min_x = min_x; + self + } + #[inline] + pub fn min_y(mut self, min_y: f32) -> Self { + self.inner.min_y = min_y; + self + } + #[inline] + pub fn min_z(mut self, min_z: f32) -> Self { + self.inner.min_z = min_z; + self + } + #[inline] + pub fn max_x(mut self, max_x: f32) -> Self { + self.inner.max_x = max_x; + self + } + #[inline] + pub fn max_y(mut self, max_y: f32) -> Self { + self.inner.max_y = max_y; + self + } + #[inline] + pub fn max_z(mut self, max_z: f32) -> Self { + self.inner.max_z = max_z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AabbPositionsKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct TransformMatrixKHR { + pub matrix: [f32; 12], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union AccelerationStructureReferenceKHR { + pub device_handle: DeviceAddress, + pub host_handle: AccelerationStructureKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureInstanceKHR { + pub transform: TransformMatrixKHR, + #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] + pub instance_custom_index_and_mask: Packed24_8, + #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] + pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureDeviceAddressInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureKHR, +} +impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureDeviceAddressInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR; +} +impl AccelerationStructureDeviceAddressInfoKHR { + pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + AccelerationStructureDeviceAddressInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + inner: AccelerationStructureDeviceAddressInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + type Target = AccelerationStructureDeviceAddressInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureVersionInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_version_data: *const [u8; 2 * UUID_SIZE], +} +impl ::std::default::Default for AccelerationStructureVersionInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_version_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureVersionInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR; +} +impl AccelerationStructureVersionInfoKHR { + pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> { + AccelerationStructureVersionInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureVersionInfoKHRBuilder<'a> { + inner: AccelerationStructureVersionInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> { + type Target = AccelerationStructureVersionInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> { + #[inline] + pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self { + self.inner.p_version_data = version_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureVersionInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyAccelerationStructureInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: AccelerationStructureKHR, + pub dst: AccelerationStructureKHR, + pub mode: CopyAccelerationStructureModeKHR, +} +impl ::std::default::Default for CopyAccelerationStructureInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: AccelerationStructureKHR::default(), + dst: AccelerationStructureKHR::default(), + mode: CopyAccelerationStructureModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for CopyAccelerationStructureInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR; +} +impl CopyAccelerationStructureInfoKHR { + pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> { + CopyAccelerationStructureInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyAccelerationStructureInfoKHRBuilder<'a> { + inner: CopyAccelerationStructureInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> { + type Target = CopyAccelerationStructureInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> { + #[inline] + pub fn src(mut self, src: AccelerationStructureKHR) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyAccelerationStructureInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyAccelerationStructureToMemoryInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: AccelerationStructureKHR, + pub dst: DeviceOrHostAddressKHR, + pub mode: CopyAccelerationStructureModeKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &self.src) + .field("dst", &"union") + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: AccelerationStructureKHR::default(), + dst: DeviceOrHostAddressKHR::default(), + mode: CopyAccelerationStructureModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for CopyAccelerationStructureToMemoryInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; +} +impl CopyAccelerationStructureToMemoryInfoKHR { + pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + CopyAccelerationStructureToMemoryInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + inner: CopyAccelerationStructureToMemoryInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + type Target = CopyAccelerationStructureToMemoryInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + #[inline] + pub fn src(mut self, src: AccelerationStructureKHR) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyAccelerationStructureToMemoryInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMemoryToAccelerationStructureInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: DeviceOrHostAddressConstKHR, + pub dst: AccelerationStructureKHR, + pub mode: CopyAccelerationStructureModeKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &"union") + .field("dst", &self.dst) + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: DeviceOrHostAddressConstKHR::default(), + dst: AccelerationStructureKHR::default(), + mode: CopyAccelerationStructureModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for CopyMemoryToAccelerationStructureInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; +} +impl CopyMemoryToAccelerationStructureInfoKHR { + pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + CopyMemoryToAccelerationStructureInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + inner: CopyMemoryToAccelerationStructureInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + type Target = CopyMemoryToAccelerationStructureInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + #[inline] + pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMemoryToAccelerationStructureInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingPipelineInterfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_pipeline_ray_payload_size: u32, + pub max_pipeline_ray_hit_attribute_size: u32, +} +impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_pipeline_ray_payload_size: u32::default(), + max_pipeline_ray_hit_attribute_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for RayTracingPipelineInterfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; +} +impl RayTracingPipelineInterfaceCreateInfoKHR { + pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + RayTracingPipelineInterfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + inner: RayTracingPipelineInterfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + type Target = RayTracingPipelineInterfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn max_pipeline_ray_payload_size(mut self, max_pipeline_ray_payload_size: u32) -> Self { + self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size; + self + } + #[inline] + pub fn max_pipeline_ray_hit_attribute_size( + mut self, + max_pipeline_ray_hit_attribute_size: u32, + ) -> Self { + self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingPipelineInterfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineLibraryCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub library_count: u32, + pub p_libraries: *const Pipeline, +} +impl ::std::default::Default for PipelineLibraryCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + library_count: u32::default(), + p_libraries: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineLibraryCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR; +} +impl PipelineLibraryCreateInfoKHR { + pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> { + PipelineLibraryCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineLibraryCreateInfoKHRBuilder<'a> { + inner: PipelineLibraryCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHR {} +impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> { + type Target = PipelineLibraryCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> { + #[inline] + pub fn libraries(mut self, libraries: &'a [Pipeline]) -> Self { + self.inner.library_count = libraries.len() as _; + self.inner.p_libraries = libraries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineLibraryCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicStateFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; +} +impl PhysicalDeviceExtendedDynamicStateFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + #[inline] + pub fn extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self { + self.inner.extended_dynamic_state = extended_dynamic_state.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state2: Bool32, + pub extended_dynamic_state2_logic_op: Bool32, + pub extended_dynamic_state2_patch_control_points: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state2: Bool32::default(), + extended_dynamic_state2_logic_op: Bool32::default(), + extended_dynamic_state2_patch_control_points: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState2FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; +} +impl PhysicalDeviceExtendedDynamicState2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicState2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + #[inline] + pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self { + self.inner.extended_dynamic_state2 = extended_dynamic_state2.into(); + self + } + #[inline] + pub fn extended_dynamic_state2_logic_op( + mut self, + extended_dynamic_state2_logic_op: bool, + ) -> Self { + self.inner.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into(); + self + } + #[inline] + pub fn extended_dynamic_state2_patch_control_points( + mut self, + extended_dynamic_state2_patch_control_points: bool, + ) -> Self { + self.inner.extended_dynamic_state2_patch_control_points = + extended_dynamic_state2_patch_control_points.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicState2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state3_tessellation_domain_origin: Bool32, + pub extended_dynamic_state3_depth_clamp_enable: Bool32, + pub extended_dynamic_state3_polygon_mode: Bool32, + pub extended_dynamic_state3_rasterization_samples: Bool32, + pub extended_dynamic_state3_sample_mask: Bool32, + pub extended_dynamic_state3_alpha_to_coverage_enable: Bool32, + pub extended_dynamic_state3_alpha_to_one_enable: Bool32, + pub extended_dynamic_state3_logic_op_enable: Bool32, + pub extended_dynamic_state3_color_blend_enable: Bool32, + pub extended_dynamic_state3_color_blend_equation: Bool32, + pub extended_dynamic_state3_color_write_mask: Bool32, + pub extended_dynamic_state3_rasterization_stream: Bool32, + pub extended_dynamic_state3_conservative_rasterization_mode: Bool32, + pub extended_dynamic_state3_extra_primitive_overestimation_size: Bool32, + pub extended_dynamic_state3_depth_clip_enable: Bool32, + pub extended_dynamic_state3_sample_locations_enable: Bool32, + pub extended_dynamic_state3_color_blend_advanced: Bool32, + pub extended_dynamic_state3_provoking_vertex_mode: Bool32, + pub extended_dynamic_state3_line_rasterization_mode: Bool32, + pub extended_dynamic_state3_line_stipple_enable: Bool32, + pub extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32, + pub extended_dynamic_state3_viewport_w_scaling_enable: Bool32, + pub extended_dynamic_state3_viewport_swizzle: Bool32, + pub extended_dynamic_state3_coverage_to_color_enable: Bool32, + pub extended_dynamic_state3_coverage_to_color_location: Bool32, + pub extended_dynamic_state3_coverage_modulation_mode: Bool32, + pub extended_dynamic_state3_coverage_modulation_table_enable: Bool32, + pub extended_dynamic_state3_coverage_modulation_table: Bool32, + pub extended_dynamic_state3_coverage_reduction_mode: Bool32, + pub extended_dynamic_state3_representative_fragment_test_enable: Bool32, + pub extended_dynamic_state3_shading_rate_image_enable: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state3_tessellation_domain_origin: Bool32::default(), + extended_dynamic_state3_depth_clamp_enable: Bool32::default(), + extended_dynamic_state3_polygon_mode: Bool32::default(), + extended_dynamic_state3_rasterization_samples: Bool32::default(), + extended_dynamic_state3_sample_mask: Bool32::default(), + extended_dynamic_state3_alpha_to_coverage_enable: Bool32::default(), + extended_dynamic_state3_alpha_to_one_enable: Bool32::default(), + extended_dynamic_state3_logic_op_enable: Bool32::default(), + extended_dynamic_state3_color_blend_enable: Bool32::default(), + extended_dynamic_state3_color_blend_equation: Bool32::default(), + extended_dynamic_state3_color_write_mask: Bool32::default(), + extended_dynamic_state3_rasterization_stream: Bool32::default(), + extended_dynamic_state3_conservative_rasterization_mode: Bool32::default(), + extended_dynamic_state3_extra_primitive_overestimation_size: Bool32::default(), + extended_dynamic_state3_depth_clip_enable: Bool32::default(), + extended_dynamic_state3_sample_locations_enable: Bool32::default(), + extended_dynamic_state3_color_blend_advanced: Bool32::default(), + extended_dynamic_state3_provoking_vertex_mode: Bool32::default(), + extended_dynamic_state3_line_rasterization_mode: Bool32::default(), + extended_dynamic_state3_line_stipple_enable: Bool32::default(), + extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32::default(), + extended_dynamic_state3_viewport_w_scaling_enable: Bool32::default(), + extended_dynamic_state3_viewport_swizzle: Bool32::default(), + extended_dynamic_state3_coverage_to_color_enable: Bool32::default(), + extended_dynamic_state3_coverage_to_color_location: Bool32::default(), + extended_dynamic_state3_coverage_modulation_mode: Bool32::default(), + extended_dynamic_state3_coverage_modulation_table_enable: Bool32::default(), + extended_dynamic_state3_coverage_modulation_table: Bool32::default(), + extended_dynamic_state3_coverage_reduction_mode: Bool32::default(), + extended_dynamic_state3_representative_fragment_test_enable: Bool32::default(), + extended_dynamic_state3_shading_rate_image_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState3FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; +} +impl PhysicalDeviceExtendedDynamicState3FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicState3FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState3FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicState3FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + #[inline] + pub fn extended_dynamic_state3_tessellation_domain_origin( + mut self, + extended_dynamic_state3_tessellation_domain_origin: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_tessellation_domain_origin = + extended_dynamic_state3_tessellation_domain_origin.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clamp_enable( + mut self, + extended_dynamic_state3_depth_clamp_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_depth_clamp_enable = + extended_dynamic_state3_depth_clamp_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_polygon_mode( + mut self, + extended_dynamic_state3_polygon_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_polygon_mode = + extended_dynamic_state3_polygon_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_rasterization_samples( + mut self, + extended_dynamic_state3_rasterization_samples: bool, + ) -> Self { + self.inner.extended_dynamic_state3_rasterization_samples = + extended_dynamic_state3_rasterization_samples.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_sample_mask( + mut self, + extended_dynamic_state3_sample_mask: bool, + ) -> Self { + self.inner.extended_dynamic_state3_sample_mask = extended_dynamic_state3_sample_mask.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_alpha_to_coverage_enable( + mut self, + extended_dynamic_state3_alpha_to_coverage_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_alpha_to_coverage_enable = + extended_dynamic_state3_alpha_to_coverage_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_alpha_to_one_enable( + mut self, + extended_dynamic_state3_alpha_to_one_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_alpha_to_one_enable = + extended_dynamic_state3_alpha_to_one_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_logic_op_enable( + mut self, + extended_dynamic_state3_logic_op_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_logic_op_enable = + extended_dynamic_state3_logic_op_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_enable( + mut self, + extended_dynamic_state3_color_blend_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_color_blend_enable = + extended_dynamic_state3_color_blend_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_equation( + mut self, + extended_dynamic_state3_color_blend_equation: bool, + ) -> Self { + self.inner.extended_dynamic_state3_color_blend_equation = + extended_dynamic_state3_color_blend_equation.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_write_mask( + mut self, + extended_dynamic_state3_color_write_mask: bool, + ) -> Self { + self.inner.extended_dynamic_state3_color_write_mask = + extended_dynamic_state3_color_write_mask.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_rasterization_stream( + mut self, + extended_dynamic_state3_rasterization_stream: bool, + ) -> Self { + self.inner.extended_dynamic_state3_rasterization_stream = + extended_dynamic_state3_rasterization_stream.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_conservative_rasterization_mode( + mut self, + extended_dynamic_state3_conservative_rasterization_mode: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_conservative_rasterization_mode = + extended_dynamic_state3_conservative_rasterization_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_extra_primitive_overestimation_size( + mut self, + extended_dynamic_state3_extra_primitive_overestimation_size: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_extra_primitive_overestimation_size = + extended_dynamic_state3_extra_primitive_overestimation_size.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clip_enable( + mut self, + extended_dynamic_state3_depth_clip_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_depth_clip_enable = + extended_dynamic_state3_depth_clip_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_sample_locations_enable( + mut self, + extended_dynamic_state3_sample_locations_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_sample_locations_enable = + extended_dynamic_state3_sample_locations_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_advanced( + mut self, + extended_dynamic_state3_color_blend_advanced: bool, + ) -> Self { + self.inner.extended_dynamic_state3_color_blend_advanced = + extended_dynamic_state3_color_blend_advanced.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_provoking_vertex_mode( + mut self, + extended_dynamic_state3_provoking_vertex_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_provoking_vertex_mode = + extended_dynamic_state3_provoking_vertex_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_line_rasterization_mode( + mut self, + extended_dynamic_state3_line_rasterization_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_line_rasterization_mode = + extended_dynamic_state3_line_rasterization_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_line_stipple_enable( + mut self, + extended_dynamic_state3_line_stipple_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_line_stipple_enable = + extended_dynamic_state3_line_stipple_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clip_negative_one_to_one( + mut self, + extended_dynamic_state3_depth_clip_negative_one_to_one: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_depth_clip_negative_one_to_one = + extended_dynamic_state3_depth_clip_negative_one_to_one.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_viewport_w_scaling_enable( + mut self, + extended_dynamic_state3_viewport_w_scaling_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_viewport_w_scaling_enable = + extended_dynamic_state3_viewport_w_scaling_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_viewport_swizzle( + mut self, + extended_dynamic_state3_viewport_swizzle: bool, + ) -> Self { + self.inner.extended_dynamic_state3_viewport_swizzle = + extended_dynamic_state3_viewport_swizzle.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_to_color_enable( + mut self, + extended_dynamic_state3_coverage_to_color_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_coverage_to_color_enable = + extended_dynamic_state3_coverage_to_color_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_to_color_location( + mut self, + extended_dynamic_state3_coverage_to_color_location: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_coverage_to_color_location = + extended_dynamic_state3_coverage_to_color_location.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_mode( + mut self, + extended_dynamic_state3_coverage_modulation_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_coverage_modulation_mode = + extended_dynamic_state3_coverage_modulation_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_table_enable( + mut self, + extended_dynamic_state3_coverage_modulation_table_enable: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_coverage_modulation_table_enable = + extended_dynamic_state3_coverage_modulation_table_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_table( + mut self, + extended_dynamic_state3_coverage_modulation_table: bool, + ) -> Self { + self.inner.extended_dynamic_state3_coverage_modulation_table = + extended_dynamic_state3_coverage_modulation_table.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_reduction_mode( + mut self, + extended_dynamic_state3_coverage_reduction_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_coverage_reduction_mode = + extended_dynamic_state3_coverage_reduction_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_representative_fragment_test_enable( + mut self, + extended_dynamic_state3_representative_fragment_test_enable: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_representative_fragment_test_enable = + extended_dynamic_state3_representative_fragment_test_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_shading_rate_image_enable( + mut self, + extended_dynamic_state3_shading_rate_image_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_shading_rate_image_enable = + extended_dynamic_state3_shading_rate_image_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicState3FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dynamic_primitive_topology_unrestricted: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3PropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + dynamic_primitive_topology_unrestricted: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState3PropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; +} +impl PhysicalDeviceExtendedDynamicState3PropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicState3PropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExtendedDynamicState3PropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicState3PropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + #[inline] + pub fn dynamic_primitive_topology_unrestricted( + mut self, + dynamic_primitive_topology_unrestricted: bool, + ) -> Self { + self.inner.dynamic_primitive_topology_unrestricted = + dynamic_primitive_topology_unrestricted.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicState3PropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ColorBlendEquationEXT { + pub src_color_blend_factor: BlendFactor, + pub dst_color_blend_factor: BlendFactor, + pub color_blend_op: BlendOp, + pub src_alpha_blend_factor: BlendFactor, + pub dst_alpha_blend_factor: BlendFactor, + pub alpha_blend_op: BlendOp, +} +impl ColorBlendEquationEXT { + pub fn builder<'a>() -> ColorBlendEquationEXTBuilder<'a> { + ColorBlendEquationEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ColorBlendEquationEXTBuilder<'a> { + inner: ColorBlendEquationEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ColorBlendEquationEXTBuilder<'a> { + type Target = ColorBlendEquationEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ColorBlendEquationEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ColorBlendEquationEXTBuilder<'a> { + #[inline] + pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self { + self.inner.src_color_blend_factor = src_color_blend_factor; + self + } + #[inline] + pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self { + self.inner.dst_color_blend_factor = dst_color_blend_factor; + self + } + #[inline] + pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self { + self.inner.color_blend_op = color_blend_op; + self + } + #[inline] + pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self { + self.inner.src_alpha_blend_factor = src_alpha_blend_factor; + self + } + #[inline] + pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self { + self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor; + self + } + #[inline] + pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self { + self.inner.alpha_blend_op = alpha_blend_op; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ColorBlendEquationEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ColorBlendAdvancedEXT { + pub advanced_blend_op: BlendOp, + pub src_premultiplied: Bool32, + pub dst_premultiplied: Bool32, + pub blend_overlap: BlendOverlapEXT, + pub clamp_results: Bool32, +} +impl ColorBlendAdvancedEXT { + pub fn builder<'a>() -> ColorBlendAdvancedEXTBuilder<'a> { + ColorBlendAdvancedEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ColorBlendAdvancedEXTBuilder<'a> { + inner: ColorBlendAdvancedEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ColorBlendAdvancedEXTBuilder<'a> { + type Target = ColorBlendAdvancedEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ColorBlendAdvancedEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ColorBlendAdvancedEXTBuilder<'a> { + #[inline] + pub fn advanced_blend_op(mut self, advanced_blend_op: BlendOp) -> Self { + self.inner.advanced_blend_op = advanced_blend_op; + self + } + #[inline] + pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self { + self.inner.src_premultiplied = src_premultiplied.into(); + self + } + #[inline] + pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self { + self.inner.dst_premultiplied = dst_premultiplied.into(); + self + } + #[inline] + pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self { + self.inner.blend_overlap = blend_overlap; + self + } + #[inline] + pub fn clamp_results(mut self, clamp_results: bool) -> Self { + self.inner.clamp_results = clamp_results.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ColorBlendAdvancedEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassTransformBeginInfoQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub transform: SurfaceTransformFlagsKHR, +} +impl ::std::default::Default for RenderPassTransformBeginInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + transform: SurfaceTransformFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for RenderPassTransformBeginInfoQCOM { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; +} +impl RenderPassTransformBeginInfoQCOM { + pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> { + RenderPassTransformBeginInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> { + inner: RenderPassTransformBeginInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOMBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM {} +impl<'a> ::std::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> { + type Target = RenderPassTransformBeginInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> { + #[inline] + pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.transform = transform; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassTransformBeginInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyCommandTransformInfoQCOM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub transform: SurfaceTransformFlagsKHR, +} +impl ::std::default::Default for CopyCommandTransformInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + transform: SurfaceTransformFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for CopyCommandTransformInfoQCOM { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM; +} +impl CopyCommandTransformInfoQCOM { + pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> { + CopyCommandTransformInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyCommandTransformInfoQCOMBuilder<'a> { + inner: CopyCommandTransformInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOMBuilder<'_> {} +unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM {} +unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOMBuilder<'_> {} +unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM {} +impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> { + type Target = CopyCommandTransformInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> { + #[inline] + pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.transform = transform; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyCommandTransformInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub transform: SurfaceTransformFlagsKHR, + pub render_area: Rect2D, +} +impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + transform: SurfaceTransformFlagsKHR::default(), + render_area: Rect2D::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceRenderPassTransformInfoQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM; +} +impl CommandBufferInheritanceRenderPassTransformInfoQCOM { + pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + inner: CommandBufferInheritanceRenderPassTransformInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceRenderPassTransformInfoQCOM +{ +} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + #[inline] + pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.transform = transform; + self + } + #[inline] + pub fn render_area(mut self, render_area: Rect2D) -> Self { + self.inner.render_area = render_area; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub diagnostics_config: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + diagnostics_config: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDiagnosticsConfigFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; +} +impl PhysicalDeviceDiagnosticsConfigFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + inner: PhysicalDeviceDiagnosticsConfigFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + #[inline] + pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self { + self.inner.diagnostics_config = diagnostics_config.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceDiagnosticsConfigCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceDiagnosticsConfigFlagsNV, +} +impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceDiagnosticsConfigFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for DeviceDiagnosticsConfigCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; +} +impl DeviceDiagnosticsConfigCreateInfoNV { + pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + DeviceDiagnosticsConfigCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + inner: DeviceDiagnosticsConfigCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV {} +impl<'a> ::std::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + type Target = DeviceDiagnosticsConfigCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceDiagnosticsConfigFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceDiagnosticsConfigCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_zero_initialize_workgroup_memory: Bool32, +} +impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_zero_initialize_workgroup_memory: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; +} +impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + #[inline] + pub fn shader_zero_initialize_workgroup_memory( + mut self, + shader_zero_initialize_workgroup_memory: bool, + ) -> Self { + self.inner.shader_zero_initialize_workgroup_memory = + shader_zero_initialize_workgroup_memory.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_subgroup_uniform_control_flow: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_subgroup_uniform_control_flow: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; +} +impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> +{ + type Target = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + #[inline] + pub fn shader_subgroup_uniform_control_flow( + mut self, + shader_subgroup_uniform_control_flow: bool, + ) -> Self { + self.inner.shader_subgroup_uniform_control_flow = + shader_subgroup_uniform_control_flow.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRobustness2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_buffer_access2: Bool32, + pub robust_image_access2: Bool32, + pub null_descriptor: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + robust_buffer_access2: Bool32::default(), + robust_image_access2: Bool32::default(), + null_descriptor: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRobustness2FeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT; +} +impl PhysicalDeviceRobustness2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + PhysicalDeviceRobustness2FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceRobustness2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceRobustness2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + #[inline] + pub fn robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self { + self.inner.robust_buffer_access2 = robust_buffer_access2.into(); + self + } + #[inline] + pub fn robust_image_access2(mut self, robust_image_access2: bool) -> Self { + self.inner.robust_image_access2 = robust_image_access2.into(); + self + } + #[inline] + pub fn null_descriptor(mut self, null_descriptor: bool) -> Self { + self.inner.null_descriptor = null_descriptor.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRobustness2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRobustness2PropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_storage_buffer_access_size_alignment: DeviceSize, + pub robust_uniform_buffer_access_size_alignment: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + robust_storage_buffer_access_size_alignment: DeviceSize::default(), + robust_uniform_buffer_access_size_alignment: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRobustness2PropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT; +} +impl PhysicalDeviceRobustness2PropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + PhysicalDeviceRobustness2PropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + inner: PhysicalDeviceRobustness2PropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceRobustness2PropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + #[inline] + pub fn robust_storage_buffer_access_size_alignment( + mut self, + robust_storage_buffer_access_size_alignment: DeviceSize, + ) -> Self { + self.inner.robust_storage_buffer_access_size_alignment = + robust_storage_buffer_access_size_alignment; + self + } + #[inline] + pub fn robust_uniform_buffer_access_size_alignment( + mut self, + robust_uniform_buffer_access_size_alignment: DeviceSize, + ) -> Self { + self.inner.robust_uniform_buffer_access_size_alignment = + robust_uniform_buffer_access_size_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRobustness2PropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageRobustnessFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_image_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageRobustnessFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + robust_image_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageRobustnessFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; +} +impl PhysicalDeviceImageRobustnessFeatures { + pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + PhysicalDeviceImageRobustnessFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + inner: PhysicalDeviceImageRobustnessFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + type Target = PhysicalDeviceImageRobustnessFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + #[inline] + pub fn robust_image_access(mut self, robust_image_access: bool) -> Self { + self.inner.robust_image_access = robust_image_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageRobustnessFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub workgroup_memory_explicit_layout: Bool32, + pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32, + pub workgroup_memory_explicit_layout8_bit_access: Bool32, + pub workgroup_memory_explicit_layout16_bit_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + workgroup_memory_explicit_layout: Bool32::default(), + workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(), + workgroup_memory_explicit_layout8_bit_access: Bool32::default(), + workgroup_memory_explicit_layout16_bit_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; +} +impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { + PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { + #[inline] + pub fn workgroup_memory_explicit_layout( + mut self, + workgroup_memory_explicit_layout: bool, + ) -> Self { + self.inner.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into(); + self + } + #[inline] + pub fn workgroup_memory_explicit_layout_scalar_block_layout( + mut self, + workgroup_memory_explicit_layout_scalar_block_layout: bool, + ) -> Self { + self.inner + .workgroup_memory_explicit_layout_scalar_block_layout = + workgroup_memory_explicit_layout_scalar_block_layout.into(); + self + } + #[inline] + pub fn workgroup_memory_explicit_layout8_bit_access( + mut self, + workgroup_memory_explicit_layout8_bit_access: bool, + ) -> Self { + self.inner.workgroup_memory_explicit_layout8_bit_access = + workgroup_memory_explicit_layout8_bit_access.into(); + self + } + #[inline] + pub fn workgroup_memory_explicit_layout16_bit_access( + mut self, + workgroup_memory_explicit_layout16_bit_access: bool, + ) -> Self { + self.inner.workgroup_memory_explicit_layout16_bit_access = + workgroup_memory_explicit_layout16_bit_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePortabilitySubsetFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub constant_alpha_color_blend_factors: Bool32, + pub events: Bool32, + pub image_view_format_reinterpretation: Bool32, + pub image_view_format_swizzle: Bool32, + pub image_view2_d_on3_d_image: Bool32, + pub multisample_array_image: Bool32, + pub mutable_comparison_samplers: Bool32, + pub point_polygons: Bool32, + pub sampler_mip_lod_bias: Bool32, + pub separate_stencil_mask_ref: Bool32, + pub shader_sample_rate_interpolation_functions: Bool32, + pub tessellation_isolines: Bool32, + pub tessellation_point_mode: Bool32, + pub triangle_fans: Bool32, + pub vertex_attribute_access_beyond_stride: Bool32, +} +impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + constant_alpha_color_blend_factors: Bool32::default(), + events: Bool32::default(), + image_view_format_reinterpretation: Bool32::default(), + image_view_format_swizzle: Bool32::default(), + image_view2_d_on3_d_image: Bool32::default(), + multisample_array_image: Bool32::default(), + mutable_comparison_samplers: Bool32::default(), + point_polygons: Bool32::default(), + sampler_mip_lod_bias: Bool32::default(), + separate_stencil_mask_ref: Bool32::default(), + shader_sample_rate_interpolation_functions: Bool32::default(), + tessellation_isolines: Bool32::default(), + tessellation_point_mode: Bool32::default(), + triangle_fans: Bool32::default(), + vertex_attribute_access_beyond_stride: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePortabilitySubsetFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; +} +impl PhysicalDevicePortabilitySubsetFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + PhysicalDevicePortabilitySubsetFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePortabilitySubsetFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePortabilitySubsetFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + #[inline] + pub fn constant_alpha_color_blend_factors( + mut self, + constant_alpha_color_blend_factors: bool, + ) -> Self { + self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into(); + self + } + #[inline] + pub fn events(mut self, events: bool) -> Self { + self.inner.events = events.into(); + self + } + #[inline] + pub fn image_view_format_reinterpretation( + mut self, + image_view_format_reinterpretation: bool, + ) -> Self { + self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into(); + self + } + #[inline] + pub fn image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self { + self.inner.image_view_format_swizzle = image_view_format_swizzle.into(); + self + } + #[inline] + pub fn image_view2_d_on3_d_image(mut self, image_view2_d_on3_d_image: bool) -> Self { + self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into(); + self + } + #[inline] + pub fn multisample_array_image(mut self, multisample_array_image: bool) -> Self { + self.inner.multisample_array_image = multisample_array_image.into(); + self + } + #[inline] + pub fn mutable_comparison_samplers(mut self, mutable_comparison_samplers: bool) -> Self { + self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into(); + self + } + #[inline] + pub fn point_polygons(mut self, point_polygons: bool) -> Self { + self.inner.point_polygons = point_polygons.into(); + self + } + #[inline] + pub fn sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self { + self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into(); + self + } + #[inline] + pub fn separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self { + self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into(); + self + } + #[inline] + pub fn shader_sample_rate_interpolation_functions( + mut self, + shader_sample_rate_interpolation_functions: bool, + ) -> Self { + self.inner.shader_sample_rate_interpolation_functions = + shader_sample_rate_interpolation_functions.into(); + self + } + #[inline] + pub fn tessellation_isolines(mut self, tessellation_isolines: bool) -> Self { + self.inner.tessellation_isolines = tessellation_isolines.into(); + self + } + #[inline] + pub fn tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self { + self.inner.tessellation_point_mode = tessellation_point_mode.into(); + self + } + #[inline] + pub fn triangle_fans(mut self, triangle_fans: bool) -> Self { + self.inner.triangle_fans = triangle_fans.into(); + self + } + #[inline] + pub fn vertex_attribute_access_beyond_stride( + mut self, + vertex_attribute_access_beyond_stride: bool, + ) -> Self { + self.inner.vertex_attribute_access_beyond_stride = + vertex_attribute_access_beyond_stride.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePortabilitySubsetPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_vertex_input_binding_stride_alignment: u32, +} +impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_vertex_input_binding_stride_alignment: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePortabilitySubsetPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; +} +impl PhysicalDevicePortabilitySubsetPropertiesKHR { + pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + PhysicalDevicePortabilitySubsetPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + inner: PhysicalDevicePortabilitySubsetPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + type Target = PhysicalDevicePortabilitySubsetPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + #[inline] + pub fn min_vertex_input_binding_stride_alignment( + mut self, + min_vertex_input_binding_stride_alignment: u32, + ) -> Self { + self.inner.min_vertex_input_binding_stride_alignment = + min_vertex_input_binding_stride_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevice4444FormatsFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_a4r4g4b4: Bool32, + pub format_a4b4g4r4: Bool32, +} +impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format_a4r4g4b4: Bool32::default(), + format_a4b4g4r4: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevice4444FormatsFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; +} +impl PhysicalDevice4444FormatsFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + PhysicalDevice4444FormatsFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + inner: PhysicalDevice4444FormatsFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + type Target = PhysicalDevice4444FormatsFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + #[inline] + pub fn format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self { + self.inner.format_a4r4g4b4 = format_a4r4g4b4.into(); + self + } + #[inline] + pub fn format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self { + self.inner.format_a4b4g4r4 = format_a4b4g4r4.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevice4444FormatsFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subpass_shading: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subpass_shading: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubpassShadingFeaturesHUAWEI { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; +} +impl PhysicalDeviceSubpassShadingFeaturesHUAWEI { + pub fn builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassShadingFeaturesHUAWEI {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEI {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + type Target = PhysicalDeviceSubpassShadingFeaturesHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + #[inline] + pub fn subpass_shading(mut self, subpass_shading: bool) -> Self { + self.inner.subpass_shading = subpass_shading.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubpassShadingFeaturesHUAWEI { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCopy2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_offset: DeviceSize, + pub dst_offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for BufferCopy2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_offset: DeviceSize::default(), + dst_offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BufferCopy2 { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COPY_2; +} +impl BufferCopy2 { + pub fn builder<'a>() -> BufferCopy2Builder<'a> { + BufferCopy2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCopy2Builder<'a> { + inner: BufferCopy2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCopy2Builder<'a> { + type Target = BufferCopy2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCopy2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCopy2Builder<'a> { + #[inline] + pub fn src_offset(mut self, src_offset: DeviceSize) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCopy2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCopy2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ::std::default::Default for ImageCopy2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offset: Offset3D::default(), + dst_subresource: ImageSubresourceLayers::default(), + dst_offset: Offset3D::default(), + extent: Extent3D::default(), + } + } +} +unsafe impl TaggedStructure for ImageCopy2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COPY_2; +} +impl ImageCopy2 { + pub fn builder<'a>() -> ImageCopy2Builder<'a> { + ImageCopy2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCopy2Builder<'a> { + inner: ImageCopy2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageCopy2Builder<'a> { + type Target = ImageCopy2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCopy2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCopy2Builder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offset(mut self, src_offset: Offset3D) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCopy2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageBlit2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offsets: [Offset3D; 2], + pub dst_subresource: ImageSubresourceLayers, + pub dst_offsets: [Offset3D; 2], +} +impl ::std::default::Default for ImageBlit2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offsets: unsafe { ::std::mem::zeroed() }, + dst_subresource: ImageSubresourceLayers::default(), + dst_offsets: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImageBlit2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_BLIT_2; +} +impl ImageBlit2 { + pub fn builder<'a>() -> ImageBlit2Builder<'a> { + ImageBlit2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageBlit2Builder<'a> { + inner: ImageBlit2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageBlit2 {} +impl<'a> ::std::ops::Deref for ImageBlit2Builder<'a> { + type Target = ImageBlit2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageBlit2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageBlit2Builder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self { + self.inner.src_offsets = src_offsets; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self { + self.inner.dst_offsets = dst_offsets; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageBlit2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferImageCopy2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer_offset: DeviceSize, + pub buffer_row_length: u32, + pub buffer_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +impl ::std::default::Default for BufferImageCopy2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer_offset: DeviceSize::default(), + buffer_row_length: u32::default(), + buffer_image_height: u32::default(), + image_subresource: ImageSubresourceLayers::default(), + image_offset: Offset3D::default(), + image_extent: Extent3D::default(), + } + } +} +unsafe impl TaggedStructure for BufferImageCopy2 { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_IMAGE_COPY_2; +} +impl BufferImageCopy2 { + pub fn builder<'a>() -> BufferImageCopy2Builder<'a> { + BufferImageCopy2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferImageCopy2Builder<'a> { + inner: BufferImageCopy2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferImageCopy2 {} +impl<'a> ::std::ops::Deref for BufferImageCopy2Builder<'a> { + type Target = BufferImageCopy2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferImageCopy2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferImageCopy2Builder<'a> { + #[inline] + pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self { + self.inner.buffer_offset = buffer_offset; + self + } + #[inline] + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.inner.buffer_row_length = buffer_row_length; + self + } + #[inline] + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.inner.buffer_image_height = buffer_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.inner.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferImageCopy2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageResolve2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ::std::default::Default for ImageResolve2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offset: Offset3D::default(), + dst_subresource: ImageSubresourceLayers::default(), + dst_offset: Offset3D::default(), + extent: Extent3D::default(), + } + } +} +unsafe impl TaggedStructure for ImageResolve2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_RESOLVE_2; +} +impl ImageResolve2 { + pub fn builder<'a>() -> ImageResolve2Builder<'a> { + ImageResolve2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageResolve2Builder<'a> { + inner: ImageResolve2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageResolve2Builder<'a> { + type Target = ImageResolve2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageResolve2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageResolve2Builder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offset(mut self, src_offset: Offset3D) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageResolve2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyBufferInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_buffer: Buffer, + pub dst_buffer: Buffer, + pub region_count: u32, + pub p_regions: *const BufferCopy2, +} +impl ::std::default::Default for CopyBufferInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_buffer: Buffer::default(), + dst_buffer: Buffer::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CopyBufferInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_BUFFER_INFO_2; +} +impl CopyBufferInfo2 { + pub fn builder<'a>() -> CopyBufferInfo2Builder<'a> { + CopyBufferInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyBufferInfo2Builder<'a> { + inner: CopyBufferInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyBufferInfo2Builder<'a> { + type Target = CopyBufferInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyBufferInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyBufferInfo2Builder<'a> { + #[inline] + pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { + self.inner.src_buffer = src_buffer; + self + } + #[inline] + pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self { + self.inner.dst_buffer = dst_buffer; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [BufferCopy2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyBufferInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyImageInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageCopy2, +} +impl ::std::default::Default for CopyImageInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CopyImageInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_INFO_2; +} +impl CopyImageInfo2 { + pub fn builder<'a>() -> CopyImageInfo2Builder<'a> { + CopyImageInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyImageInfo2Builder<'a> { + inner: CopyImageInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyImageInfo2Builder<'a> { + type Target = CopyImageInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyImageInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyImageInfo2Builder<'a> { + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.inner.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.inner.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.inner.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.inner.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [ImageCopy2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyImageInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BlitImageInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageBlit2, + pub filter: Filter, +} +impl ::std::default::Default for BlitImageInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + filter: Filter::default(), + } + } +} +unsafe impl TaggedStructure for BlitImageInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::BLIT_IMAGE_INFO_2; +} +impl BlitImageInfo2 { + pub fn builder<'a>() -> BlitImageInfo2Builder<'a> { + BlitImageInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BlitImageInfo2Builder<'a> { + inner: BlitImageInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BlitImageInfo2Builder<'a> { + type Target = BlitImageInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BlitImageInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BlitImageInfo2Builder<'a> { + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.inner.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.inner.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.inner.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.inner.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [ImageBlit2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[inline] + pub fn filter(mut self, filter: Filter) -> Self { + self.inner.filter = filter; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BlitImageInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyBufferToImageInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_buffer: Buffer, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const BufferImageCopy2, +} +impl ::std::default::Default for CopyBufferToImageInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_buffer: Buffer::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CopyBufferToImageInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_BUFFER_TO_IMAGE_INFO_2; +} +impl CopyBufferToImageInfo2 { + pub fn builder<'a>() -> CopyBufferToImageInfo2Builder<'a> { + CopyBufferToImageInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyBufferToImageInfo2Builder<'a> { + inner: CopyBufferToImageInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2Builder<'a> { + type Target = CopyBufferToImageInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyBufferToImageInfo2Builder<'a> { + #[inline] + pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { + self.inner.src_buffer = src_buffer; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.inner.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.inner.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyBufferToImageInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyImageToBufferInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_buffer: Buffer, + pub region_count: u32, + pub p_regions: *const BufferImageCopy2, +} +impl ::std::default::Default for CopyImageToBufferInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_buffer: Buffer::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CopyImageToBufferInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_TO_BUFFER_INFO_2; +} +impl CopyImageToBufferInfo2 { + pub fn builder<'a>() -> CopyImageToBufferInfo2Builder<'a> { + CopyImageToBufferInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyImageToBufferInfo2Builder<'a> { + inner: CopyImageToBufferInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2Builder<'a> { + type Target = CopyImageToBufferInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyImageToBufferInfo2Builder<'a> { + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.inner.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.inner.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self { + self.inner.dst_buffer = dst_buffer; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyImageToBufferInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ResolveImageInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageResolve2, +} +impl ::std::default::Default for ResolveImageInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ResolveImageInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::RESOLVE_IMAGE_INFO_2; +} +impl ResolveImageInfo2 { + pub fn builder<'a>() -> ResolveImageInfo2Builder<'a> { + ResolveImageInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ResolveImageInfo2Builder<'a> { + inner: ResolveImageInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ResolveImageInfo2Builder<'a> { + type Target = ResolveImageInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ResolveImageInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ResolveImageInfo2Builder<'a> { + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.inner.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.inner.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.inner.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.inner.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [ImageResolve2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ResolveImageInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_image_int64_atomics: Bool32, + pub sparse_image_int64_atomics: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_image_int64_atomics: Bool32::default(), + sparse_image_int64_atomics: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; +} +impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_image_int64_atomics(mut self, shader_image_int64_atomics: bool) -> Self { + self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into(); + self + } + #[inline] + pub fn sparse_image_int64_atomics(mut self, sparse_image_int64_atomics: bool) -> Self { + self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FragmentShadingRateAttachmentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_fragment_shading_rate_attachment: *const AttachmentReference2, + pub shading_rate_attachment_texel_size: Extent2D, +} +impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_fragment_shading_rate_attachment: ::std::ptr::null(), + shading_rate_attachment_texel_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for FragmentShadingRateAttachmentInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; +} +impl FragmentShadingRateAttachmentInfoKHR { + pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + FragmentShadingRateAttachmentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + inner: FragmentShadingRateAttachmentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR {} +impl<'a> ::std::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + type Target = FragmentShadingRateAttachmentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + #[inline] + pub fn fragment_shading_rate_attachment( + mut self, + fragment_shading_rate_attachment: &'a AttachmentReference2, + ) -> Self { + self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment; + self + } + #[inline] + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FragmentShadingRateAttachmentInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineFragmentShadingRateStateCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_size: Extent2D, + pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], +} +impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fragment_size: Extent2D::default(), + combiner_ops: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PipelineFragmentShadingRateStateCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; +} +impl PipelineFragmentShadingRateStateCreateInfoKHR { + pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + PipelineFragmentShadingRateStateCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + inner: PipelineFragmentShadingRateStateCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR {} +impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + type Target = PipelineFragmentShadingRateStateCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + #[inline] + pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self { + self.inner.fragment_size = fragment_size; + self + } + #[inline] + pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self { + self.inner.combiner_ops = combiner_ops; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_fragment_shading_rate: Bool32, + pub primitive_fragment_shading_rate: Bool32, + pub attachment_fragment_shading_rate: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_fragment_shading_rate: Bool32::default(), + primitive_fragment_shading_rate: Bool32::default(), + attachment_fragment_shading_rate: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; +} +impl PhysicalDeviceFragmentShadingRateFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + #[inline] + pub fn pipeline_fragment_shading_rate(mut self, pipeline_fragment_shading_rate: bool) -> Self { + self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into(); + self + } + #[inline] + pub fn primitive_fragment_shading_rate( + mut self, + primitive_fragment_shading_rate: bool, + ) -> Self { + self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into(); + self + } + #[inline] + pub fn attachment_fragment_shading_rate( + mut self, + attachment_fragment_shading_rate: bool, + ) -> Self { + self.inner.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_fragment_shading_rate_attachment_texel_size: Extent2D, + pub max_fragment_shading_rate_attachment_texel_size: Extent2D, + pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, + pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32, + pub layered_shading_rate_attachments: Bool32, + pub fragment_shading_rate_non_trivial_combiner_ops: Bool32, + pub max_fragment_size: Extent2D, + pub max_fragment_size_aspect_ratio: u32, + pub max_fragment_shading_rate_coverage_samples: u32, + pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags, + pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32, + pub fragment_shading_rate_with_sample_mask: Bool32, + pub fragment_shading_rate_with_shader_sample_mask: Bool32, + pub fragment_shading_rate_with_conservative_rasterization: Bool32, + pub fragment_shading_rate_with_fragment_shader_interlock: Bool32, + pub fragment_shading_rate_with_custom_sample_locations: Bool32, + pub fragment_shading_rate_strict_multiply_combiner: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_fragment_shading_rate_attachment_texel_size: Extent2D::default(), + max_fragment_shading_rate_attachment_texel_size: Extent2D::default(), + max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32::default(), + primitive_fragment_shading_rate_with_multiple_viewports: Bool32::default(), + layered_shading_rate_attachments: Bool32::default(), + fragment_shading_rate_non_trivial_combiner_ops: Bool32::default(), + max_fragment_size: Extent2D::default(), + max_fragment_size_aspect_ratio: u32::default(), + max_fragment_shading_rate_coverage_samples: u32::default(), + max_fragment_shading_rate_rasterization_samples: SampleCountFlags::default(), + fragment_shading_rate_with_shader_depth_stencil_writes: Bool32::default(), + fragment_shading_rate_with_sample_mask: Bool32::default(), + fragment_shading_rate_with_shader_sample_mask: Bool32::default(), + fragment_shading_rate_with_conservative_rasterization: Bool32::default(), + fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(), + fragment_shading_rate_with_custom_sample_locations: Bool32::default(), + fragment_shading_rate_strict_multiply_combiner: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRatePropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; +} +impl PhysicalDeviceFragmentShadingRatePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRatePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + #[inline] + pub fn min_fragment_shading_rate_attachment_texel_size( + mut self, + min_fragment_shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.min_fragment_shading_rate_attachment_texel_size = + min_fragment_shading_rate_attachment_texel_size; + self + } + #[inline] + pub fn max_fragment_shading_rate_attachment_texel_size( + mut self, + max_fragment_shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.max_fragment_shading_rate_attachment_texel_size = + max_fragment_shading_rate_attachment_texel_size; + self + } + #[inline] + pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio( + mut self, + max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, + ) -> Self { + self.inner + .max_fragment_shading_rate_attachment_texel_size_aspect_ratio = + max_fragment_shading_rate_attachment_texel_size_aspect_ratio; + self + } + #[inline] + pub fn primitive_fragment_shading_rate_with_multiple_viewports( + mut self, + primitive_fragment_shading_rate_with_multiple_viewports: bool, + ) -> Self { + self.inner + .primitive_fragment_shading_rate_with_multiple_viewports = + primitive_fragment_shading_rate_with_multiple_viewports.into(); + self + } + #[inline] + pub fn layered_shading_rate_attachments( + mut self, + layered_shading_rate_attachments: bool, + ) -> Self { + self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into(); + self + } + #[inline] + pub fn fragment_shading_rate_non_trivial_combiner_ops( + mut self, + fragment_shading_rate_non_trivial_combiner_ops: bool, + ) -> Self { + self.inner.fragment_shading_rate_non_trivial_combiner_ops = + fragment_shading_rate_non_trivial_combiner_ops.into(); + self + } + #[inline] + pub fn max_fragment_size(mut self, max_fragment_size: Extent2D) -> Self { + self.inner.max_fragment_size = max_fragment_size; + self + } + #[inline] + pub fn max_fragment_size_aspect_ratio(mut self, max_fragment_size_aspect_ratio: u32) -> Self { + self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio; + self + } + #[inline] + pub fn max_fragment_shading_rate_coverage_samples( + mut self, + max_fragment_shading_rate_coverage_samples: u32, + ) -> Self { + self.inner.max_fragment_shading_rate_coverage_samples = + max_fragment_shading_rate_coverage_samples; + self + } + #[inline] + pub fn max_fragment_shading_rate_rasterization_samples( + mut self, + max_fragment_shading_rate_rasterization_samples: SampleCountFlags, + ) -> Self { + self.inner.max_fragment_shading_rate_rasterization_samples = + max_fragment_shading_rate_rasterization_samples; + self + } + #[inline] + pub fn fragment_shading_rate_with_shader_depth_stencil_writes( + mut self, + fragment_shading_rate_with_shader_depth_stencil_writes: bool, + ) -> Self { + self.inner + .fragment_shading_rate_with_shader_depth_stencil_writes = + fragment_shading_rate_with_shader_depth_stencil_writes.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_sample_mask( + mut self, + fragment_shading_rate_with_sample_mask: bool, + ) -> Self { + self.inner.fragment_shading_rate_with_sample_mask = + fragment_shading_rate_with_sample_mask.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_shader_sample_mask( + mut self, + fragment_shading_rate_with_shader_sample_mask: bool, + ) -> Self { + self.inner.fragment_shading_rate_with_shader_sample_mask = + fragment_shading_rate_with_shader_sample_mask.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_conservative_rasterization( + mut self, + fragment_shading_rate_with_conservative_rasterization: bool, + ) -> Self { + self.inner + .fragment_shading_rate_with_conservative_rasterization = + fragment_shading_rate_with_conservative_rasterization.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_fragment_shader_interlock( + mut self, + fragment_shading_rate_with_fragment_shader_interlock: bool, + ) -> Self { + self.inner + .fragment_shading_rate_with_fragment_shader_interlock = + fragment_shading_rate_with_fragment_shader_interlock.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_custom_sample_locations( + mut self, + fragment_shading_rate_with_custom_sample_locations: bool, + ) -> Self { + self.inner + .fragment_shading_rate_with_custom_sample_locations = + fragment_shading_rate_with_custom_sample_locations.into(); + self + } + #[inline] + pub fn fragment_shading_rate_strict_multiply_combiner( + mut self, + fragment_shading_rate_strict_multiply_combiner: bool, + ) -> Self { + self.inner.fragment_shading_rate_strict_multiply_combiner = + fragment_shading_rate_strict_multiply_combiner.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sample_counts: SampleCountFlags, + pub fragment_size: Extent2D, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + sample_counts: SampleCountFlags::default(), + fragment_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; +} +impl PhysicalDeviceFragmentShadingRateKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRateKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + #[inline] + pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self { + self.inner.sample_counts = sample_counts; + self + } + #[inline] + pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self { + self.inner.fragment_size = fragment_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderTerminateInvocationFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_terminate_invocation: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_terminate_invocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderTerminateInvocationFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; +} +impl PhysicalDeviceShaderTerminateInvocationFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + PhysicalDeviceShaderTerminateInvocationFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderTerminateInvocationFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderTerminateInvocationFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + #[inline] + pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self { + self.inner.shader_terminate_invocation = shader_terminate_invocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shading_rate_enums: Bool32, + pub supersample_fragment_shading_rates: Bool32, + pub no_invocation_fragment_shading_rates: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_shading_rate_enums: Bool32::default(), + supersample_fragment_shading_rates: Bool32::default(), + no_invocation_fragment_shading_rates: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; +} +impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + #[inline] + pub fn fragment_shading_rate_enums(mut self, fragment_shading_rate_enums: bool) -> Self { + self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into(); + self + } + #[inline] + pub fn supersample_fragment_shading_rates( + mut self, + supersample_fragment_shading_rates: bool, + ) -> Self { + self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into(); + self + } + #[inline] + pub fn no_invocation_fragment_shading_rates( + mut self, + no_invocation_fragment_shading_rates: bool, + ) -> Self { + self.inner.no_invocation_fragment_shading_rates = + no_invocation_fragment_shading_rates.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_fragment_shading_rate_invocation_count: SampleCountFlags, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_fragment_shading_rate_invocation_count: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; +} +impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + #[inline] + pub fn max_fragment_shading_rate_invocation_count( + mut self, + max_fragment_shading_rate_invocation_count: SampleCountFlags, + ) -> Self { + self.inner.max_fragment_shading_rate_invocation_count = + max_fragment_shading_rate_invocation_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shading_rate_type: FragmentShadingRateTypeNV, + pub shading_rate: FragmentShadingRateNV, + pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], +} +impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + shading_rate_type: FragmentShadingRateTypeNV::default(), + shading_rate: FragmentShadingRateNV::default(), + combiner_ops: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PipelineFragmentShadingRateEnumStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; +} +impl PipelineFragmentShadingRateEnumStateCreateInfoNV { + pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + inner: PipelineFragmentShadingRateEnumStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn shading_rate_type(mut self, shading_rate_type: FragmentShadingRateTypeNV) -> Self { + self.inner.shading_rate_type = shading_rate_type; + self + } + #[inline] + pub fn shading_rate(mut self, shading_rate: FragmentShadingRateNV) -> Self { + self.inner.shading_rate = shading_rate; + self + } + #[inline] + pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self { + self.inner.combiner_ops = combiner_ops; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureBuildSizesInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure_size: DeviceSize, + pub update_scratch_size: DeviceSize, + pub build_scratch_size: DeviceSize, +} +impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure_size: DeviceSize::default(), + update_scratch_size: DeviceSize::default(), + build_scratch_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureBuildSizesInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; +} +impl AccelerationStructureBuildSizesInfoKHR { + pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + AccelerationStructureBuildSizesInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + inner: AccelerationStructureBuildSizesInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + type Target = AccelerationStructureBuildSizesInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + #[inline] + pub fn acceleration_structure_size(mut self, acceleration_structure_size: DeviceSize) -> Self { + self.inner.acceleration_structure_size = acceleration_structure_size; + self + } + #[inline] + pub fn update_scratch_size(mut self, update_scratch_size: DeviceSize) -> Self { + self.inner.update_scratch_size = update_scratch_size; + self + } + #[inline] + pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self { + self.inner.build_scratch_size = build_scratch_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureBuildSizesInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image2_d_view_of3_d: Bool32, + pub sampler2_d_view_of3_d: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImage2DViewOf3DFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image2_d_view_of3_d: Bool32::default(), + sampler2_d_view_of3_d: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImage2DViewOf3DFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; +} +impl PhysicalDeviceImage2DViewOf3DFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImage2DViewOf3DFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImage2DViewOf3DFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + #[inline] + pub fn image2_d_view_of3_d(mut self, image2_d_view_of3_d: bool) -> Self { + self.inner.image2_d_view_of3_d = image2_d_view_of3_d.into(); + self + } + #[inline] + pub fn sampler2_d_view_of3_d(mut self, sampler2_d_view_of3_d: bool) -> Self { + self.inner.sampler2_d_view_of3_d = sampler2_d_view_of3_d.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImage2DViewOf3DFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub mutable_descriptor_type: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + mutable_descriptor_type: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; +} +impl PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMutableDescriptorTypeFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + #[inline] + pub fn mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self { + self.inner.mutable_descriptor_type = mutable_descriptor_type.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MutableDescriptorTypeListEXT { + pub descriptor_type_count: u32, + pub p_descriptor_types: *const DescriptorType, +} +impl ::std::default::Default for MutableDescriptorTypeListEXT { + #[inline] + fn default() -> Self { + Self { + descriptor_type_count: u32::default(), + p_descriptor_types: ::std::ptr::null(), + } + } +} +impl MutableDescriptorTypeListEXT { + pub fn builder<'a>() -> MutableDescriptorTypeListEXTBuilder<'a> { + MutableDescriptorTypeListEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MutableDescriptorTypeListEXTBuilder<'a> { + inner: MutableDescriptorTypeListEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MutableDescriptorTypeListEXTBuilder<'a> { + type Target = MutableDescriptorTypeListEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MutableDescriptorTypeListEXTBuilder<'a> { + #[inline] + pub fn descriptor_types(mut self, descriptor_types: &'a [DescriptorType]) -> Self { + self.inner.descriptor_type_count = descriptor_types.len() as _; + self.inner.p_descriptor_types = descriptor_types.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MutableDescriptorTypeListEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MutableDescriptorTypeCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mutable_descriptor_type_list_count: u32, + pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListEXT, +} +impl ::std::default::Default for MutableDescriptorTypeCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mutable_descriptor_type_list_count: u32::default(), + p_mutable_descriptor_type_lists: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for MutableDescriptorTypeCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; +} +impl MutableDescriptorTypeCreateInfoEXT { + pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + MutableDescriptorTypeCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + inner: MutableDescriptorTypeCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXT {} +unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXT {} +impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + type Target = MutableDescriptorTypeCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + #[inline] + pub fn mutable_descriptor_type_lists( + mut self, + mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListEXT], + ) -> Self { + self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _; + self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MutableDescriptorTypeCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthClipControlFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub depth_clip_control: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + depth_clip_control: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDepthClipControlFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; +} +impl PhysicalDeviceDepthClipControlFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + PhysicalDeviceDepthClipControlFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDepthClipControlFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDepthClipControlFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + #[inline] + pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self { + self.inner.depth_clip_control = depth_clip_control.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDepthClipControlFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportDepthClipControlCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub negative_one_to_one: Bool32, +} +impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + negative_one_to_one: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportDepthClipControlCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; +} +impl PipelineViewportDepthClipControlCreateInfoEXT { + pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + PipelineViewportDepthClipControlCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + inner: PipelineViewportDepthClipControlCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportDepthClipControlCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + type Target = PipelineViewportDepthClipControlCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + #[inline] + pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self { + self.inner.negative_one_to_one = negative_one_to_one.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportDepthClipControlCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub vertex_input_dynamic_state: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + vertex_input_dynamic_state: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; +} +impl PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + #[inline] + pub fn vertex_input_dynamic_state(mut self, vertex_input_dynamic_state: bool) -> Self { + self.inner.vertex_input_dynamic_state = vertex_input_dynamic_state.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_memory_rdma: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_memory_rdma: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalMemoryRDMAFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV; +} +impl PhysicalDeviceExternalMemoryRDMAFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryRDMAFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceExternalMemoryRDMAFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + #[inline] + pub fn external_memory_rdma(mut self, external_memory_rdma: bool) -> Self { + self.inner.external_memory_rdma = external_memory_rdma.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalMemoryRDMAFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VertexInputBindingDescription2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub binding: u32, + pub stride: u32, + pub input_rate: VertexInputRate, + pub divisor: u32, +} +impl ::std::default::Default for VertexInputBindingDescription2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + binding: u32::default(), + stride: u32::default(), + input_rate: VertexInputRate::default(), + divisor: u32::default(), + } + } +} +unsafe impl TaggedStructure for VertexInputBindingDescription2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT; +} +impl VertexInputBindingDescription2EXT { + pub fn builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a> { + VertexInputBindingDescription2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputBindingDescription2EXTBuilder<'a> { + inner: VertexInputBindingDescription2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputBindingDescription2EXTBuilder<'a> { + type Target = VertexInputBindingDescription2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputBindingDescription2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputBindingDescription2EXTBuilder<'a> { + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn stride(mut self, stride: u32) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self { + self.inner.input_rate = input_rate; + self + } + #[inline] + pub fn divisor(mut self, divisor: u32) -> Self { + self.inner.divisor = divisor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputBindingDescription2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VertexInputAttributeDescription2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub location: u32, + pub binding: u32, + pub format: Format, + pub offset: u32, +} +impl ::std::default::Default for VertexInputAttributeDescription2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + location: u32::default(), + binding: u32::default(), + format: Format::default(), + offset: u32::default(), + } + } +} +unsafe impl TaggedStructure for VertexInputAttributeDescription2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT; +} +impl VertexInputAttributeDescription2EXT { + pub fn builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a> { + VertexInputAttributeDescription2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputAttributeDescription2EXTBuilder<'a> { + inner: VertexInputAttributeDescription2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputAttributeDescription2EXTBuilder<'a> { + type Target = VertexInputAttributeDescription2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescription2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> { + #[inline] + pub fn location(mut self, location: u32) -> Self { + self.inner.location = location; + self + } + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputAttributeDescription2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceColorWriteEnableFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub color_write_enable: Bool32, +} +impl ::std::default::Default for PhysicalDeviceColorWriteEnableFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + color_write_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceColorWriteEnableFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; +} +impl PhysicalDeviceColorWriteEnableFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + PhysicalDeviceColorWriteEnableFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceColorWriteEnableFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceColorWriteEnableFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + #[inline] + pub fn color_write_enable(mut self, color_write_enable: bool) -> Self { + self.inner.color_write_enable = color_write_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceColorWriteEnableFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineColorWriteCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_count: u32, + pub p_color_write_enables: *const Bool32, +} +impl ::std::default::Default for PipelineColorWriteCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment_count: u32::default(), + p_color_write_enables: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineColorWriteCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; +} +impl PipelineColorWriteCreateInfoEXT { + pub fn builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a> { + PipelineColorWriteCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineColorWriteCreateInfoEXTBuilder<'a> { + inner: PipelineColorWriteCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo + for PipelineColorWriteCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorWriteCreateInfoEXT {} +impl<'a> ::std::ops::Deref for PipelineColorWriteCreateInfoEXTBuilder<'a> { + type Target = PipelineColorWriteCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineColorWriteCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> { + #[inline] + pub fn color_write_enables(mut self, color_write_enables: &'a [Bool32]) -> Self { + self.inner.attachment_count = color_write_enables.len() as _; + self.inner.p_color_write_enables = color_write_enables.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineColorWriteCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryBarrier2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_stage_mask: PipelineStageFlags2, + pub src_access_mask: AccessFlags2, + pub dst_stage_mask: PipelineStageFlags2, + pub dst_access_mask: AccessFlags2, +} +impl ::std::default::Default for MemoryBarrier2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_stage_mask: PipelineStageFlags2::default(), + src_access_mask: AccessFlags2::default(), + dst_stage_mask: PipelineStageFlags2::default(), + dst_access_mask: AccessFlags2::default(), + } + } +} +unsafe impl TaggedStructure for MemoryBarrier2 { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_BARRIER_2; +} +impl MemoryBarrier2 { + pub fn builder<'a>() -> MemoryBarrier2Builder<'a> { + MemoryBarrier2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryBarrier2Builder<'a> { + inner: MemoryBarrier2, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2Builder<'_> {} +unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2 {} +impl<'a> ::std::ops::Deref for MemoryBarrier2Builder<'a> { + type Target = MemoryBarrier2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryBarrier2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryBarrier2Builder<'a> { + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryBarrier2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageMemoryBarrier2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_stage_mask: PipelineStageFlags2, + pub src_access_mask: AccessFlags2, + pub dst_stage_mask: PipelineStageFlags2, + pub dst_access_mask: AccessFlags2, + pub old_layout: ImageLayout, + pub new_layout: ImageLayout, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, + pub image: Image, + pub subresource_range: ImageSubresourceRange, +} +impl ::std::default::Default for ImageMemoryBarrier2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_stage_mask: PipelineStageFlags2::default(), + src_access_mask: AccessFlags2::default(), + dst_stage_mask: PipelineStageFlags2::default(), + dst_access_mask: AccessFlags2::default(), + old_layout: ImageLayout::default(), + new_layout: ImageLayout::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), + image: Image::default(), + subresource_range: ImageSubresourceRange::default(), + } + } +} +unsafe impl TaggedStructure for ImageMemoryBarrier2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_BARRIER_2; +} +impl ImageMemoryBarrier2 { + pub fn builder<'a>() -> ImageMemoryBarrier2Builder<'a> { + ImageMemoryBarrier2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageMemoryBarrier2Builder<'a> { + inner: ImageMemoryBarrier2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageMemoryBarrier2 {} +impl<'a> ::std::ops::Deref for ImageMemoryBarrier2Builder<'a> { + type Target = ImageMemoryBarrier2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageMemoryBarrier2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageMemoryBarrier2Builder<'a> { + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn old_layout(mut self, old_layout: ImageLayout) -> Self { + self.inner.old_layout = old_layout; + self + } + #[inline] + pub fn new_layout(mut self, new_layout: ImageLayout) -> Self { + self.inner.new_layout = new_layout; + self + } + #[inline] + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + #[inline] + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { + self.inner.subresource_range = subresource_range; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageMemoryBarrier2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferMemoryBarrier2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_stage_mask: PipelineStageFlags2, + pub src_access_mask: AccessFlags2, + pub dst_stage_mask: PipelineStageFlags2, + pub dst_access_mask: AccessFlags2, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for BufferMemoryBarrier2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_stage_mask: PipelineStageFlags2::default(), + src_access_mask: AccessFlags2::default(), + dst_stage_mask: PipelineStageFlags2::default(), + dst_access_mask: AccessFlags2::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BufferMemoryBarrier2 { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER_2; +} +impl BufferMemoryBarrier2 { + pub fn builder<'a>() -> BufferMemoryBarrier2Builder<'a> { + BufferMemoryBarrier2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferMemoryBarrier2Builder<'a> { + inner: BufferMemoryBarrier2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferMemoryBarrier2Builder<'a> { + type Target = BufferMemoryBarrier2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferMemoryBarrier2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferMemoryBarrier2Builder<'a> { + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + #[inline] + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferMemoryBarrier2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DependencyInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dependency_flags: DependencyFlags, + pub memory_barrier_count: u32, + pub p_memory_barriers: *const MemoryBarrier2, + pub buffer_memory_barrier_count: u32, + pub p_buffer_memory_barriers: *const BufferMemoryBarrier2, + pub image_memory_barrier_count: u32, + pub p_image_memory_barriers: *const ImageMemoryBarrier2, +} +impl ::std::default::Default for DependencyInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + dependency_flags: DependencyFlags::default(), + memory_barrier_count: u32::default(), + p_memory_barriers: ::std::ptr::null(), + buffer_memory_barrier_count: u32::default(), + p_buffer_memory_barriers: ::std::ptr::null(), + image_memory_barrier_count: u32::default(), + p_image_memory_barriers: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DependencyInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEPENDENCY_INFO; +} +impl DependencyInfo { + pub fn builder<'a>() -> DependencyInfoBuilder<'a> { + DependencyInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DependencyInfoBuilder<'a> { + inner: DependencyInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DependencyInfoBuilder<'a> { + type Target = DependencyInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DependencyInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DependencyInfoBuilder<'a> { + #[inline] + pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { + self.inner.dependency_flags = dependency_flags; + self + } + #[inline] + pub fn memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2]) -> Self { + self.inner.memory_barrier_count = memory_barriers.len() as _; + self.inner.p_memory_barriers = memory_barriers.as_ptr(); + self + } + #[inline] + pub fn buffer_memory_barriers( + mut self, + buffer_memory_barriers: &'a [BufferMemoryBarrier2], + ) -> Self { + self.inner.buffer_memory_barrier_count = buffer_memory_barriers.len() as _; + self.inner.p_buffer_memory_barriers = buffer_memory_barriers.as_ptr(); + self + } + #[inline] + pub fn image_memory_barriers( + mut self, + image_memory_barriers: &'a [ImageMemoryBarrier2], + ) -> Self { + self.inner.image_memory_barrier_count = image_memory_barriers.len() as _; + self.inner.p_image_memory_barriers = image_memory_barriers.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DependencyInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub value: u64, + pub stage_mask: PipelineStageFlags2, + pub device_index: u32, +} +impl ::std::default::Default for SemaphoreSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + value: u64::default(), + stage_mask: PipelineStageFlags2::default(), + device_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SUBMIT_INFO; +} +impl SemaphoreSubmitInfo { + pub fn builder<'a>() -> SemaphoreSubmitInfoBuilder<'a> { + SemaphoreSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreSubmitInfoBuilder<'a> { + inner: SemaphoreSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoBuilder<'a> { + type Target = SemaphoreSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreSubmitInfoBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn value(mut self, value: u64) -> Self { + self.inner.value = value; + self + } + #[inline] + pub fn stage_mask(mut self, stage_mask: PipelineStageFlags2) -> Self { + self.inner.stage_mask = stage_mask; + self + } + #[inline] + pub fn device_index(mut self, device_index: u32) -> Self { + self.inner.device_index = device_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub command_buffer: CommandBuffer, + pub device_mask: u32, +} +impl ::std::default::Default for CommandBufferSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + command_buffer: CommandBuffer::default(), + device_mask: u32::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_SUBMIT_INFO; +} +impl CommandBufferSubmitInfo { + pub fn builder<'a>() -> CommandBufferSubmitInfoBuilder<'a> { + CommandBufferSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferSubmitInfoBuilder<'a> { + inner: CommandBufferSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoBuilder<'a> { + type Target = CommandBufferSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferSubmitInfoBuilder<'a> { + #[inline] + pub fn command_buffer(mut self, command_buffer: CommandBuffer) -> Self { + self.inner.command_buffer = command_buffer; + self + } + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubmitInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SubmitFlags, + pub wait_semaphore_info_count: u32, + pub p_wait_semaphore_infos: *const SemaphoreSubmitInfo, + pub command_buffer_info_count: u32, + pub p_command_buffer_infos: *const CommandBufferSubmitInfo, + pub signal_semaphore_info_count: u32, + pub p_signal_semaphore_infos: *const SemaphoreSubmitInfo, +} +impl ::std::default::Default for SubmitInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SubmitFlags::default(), + wait_semaphore_info_count: u32::default(), + p_wait_semaphore_infos: ::std::ptr::null(), + command_buffer_info_count: u32::default(), + p_command_buffer_infos: ::std::ptr::null(), + signal_semaphore_info_count: u32::default(), + p_signal_semaphore_infos: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubmitInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::SUBMIT_INFO_2; +} +impl SubmitInfo2 { + pub fn builder<'a>() -> SubmitInfo2Builder<'a> { + SubmitInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubmitInfo2Builder<'a> { + inner: SubmitInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubmitInfo2 {} +impl<'a> ::std::ops::Deref for SubmitInfo2Builder<'a> { + type Target = SubmitInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubmitInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubmitInfo2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: SubmitFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn wait_semaphore_infos(mut self, wait_semaphore_infos: &'a [SemaphoreSubmitInfo]) -> Self { + self.inner.wait_semaphore_info_count = wait_semaphore_infos.len() as _; + self.inner.p_wait_semaphore_infos = wait_semaphore_infos.as_ptr(); + self + } + #[inline] + pub fn command_buffer_infos( + mut self, + command_buffer_infos: &'a [CommandBufferSubmitInfo], + ) -> Self { + self.inner.command_buffer_info_count = command_buffer_infos.len() as _; + self.inner.p_command_buffer_infos = command_buffer_infos.as_ptr(); + self + } + #[inline] + pub fn signal_semaphore_infos( + mut self, + signal_semaphore_infos: &'a [SemaphoreSubmitInfo], + ) -> Self { + self.inner.signal_semaphore_info_count = signal_semaphore_infos.len() as _; + self.inner.p_signal_semaphore_infos = signal_semaphore_infos.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubmitInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyCheckpointProperties2NV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub checkpoint_execution_stage_mask: PipelineStageFlags2, +} +impl ::std::default::Default for QueueFamilyCheckpointProperties2NV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + checkpoint_execution_stage_mask: PipelineStageFlags2::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyCheckpointProperties2NV { + const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; +} +impl QueueFamilyCheckpointProperties2NV { + pub fn builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a> { + QueueFamilyCheckpointProperties2NVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyCheckpointProperties2NVBuilder<'a> { + inner: QueueFamilyCheckpointProperties2NV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NVBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NV {} +impl<'a> ::std::ops::Deref for QueueFamilyCheckpointProperties2NVBuilder<'a> { + type Target = QueueFamilyCheckpointProperties2NV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointProperties2NVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> { + #[inline] + pub fn checkpoint_execution_stage_mask( + mut self, + checkpoint_execution_stage_mask: PipelineStageFlags2, + ) -> Self { + self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyCheckpointProperties2NV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CheckpointData2NV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stage: PipelineStageFlags2, + pub p_checkpoint_marker: *mut c_void, +} +impl ::std::default::Default for CheckpointData2NV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stage: PipelineStageFlags2::default(), + p_checkpoint_marker: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for CheckpointData2NV { + const STRUCTURE_TYPE: StructureType = StructureType::CHECKPOINT_DATA_2_NV; +} +impl CheckpointData2NV { + pub fn builder<'a>() -> CheckpointData2NVBuilder<'a> { + CheckpointData2NVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CheckpointData2NVBuilder<'a> { + inner: CheckpointData2NV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CheckpointData2NVBuilder<'a> { + type Target = CheckpointData2NV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CheckpointData2NVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CheckpointData2NVBuilder<'a> { + #[inline] + pub fn stage(mut self, stage: PipelineStageFlags2) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self { + self.inner.p_checkpoint_marker = checkpoint_marker; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CheckpointData2NV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSynchronization2Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub synchronization2: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSynchronization2Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + synchronization2: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSynchronization2Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; +} +impl PhysicalDeviceSynchronization2Features { + pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + PhysicalDeviceSynchronization2FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + inner: PhysicalDeviceSynchronization2Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + type Target = PhysicalDeviceSynchronization2Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + #[inline] + pub fn synchronization2(mut self, synchronization2: bool) -> Self { + self.inner.synchronization2 = synchronization2.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSynchronization2Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub primitives_generated_query: Bool32, + pub primitives_generated_query_with_rasterizer_discard: Bool32, + pub primitives_generated_query_with_non_zero_streams: Bool32, +} +impl ::std::default::Default for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + primitives_generated_query: Bool32::default(), + primitives_generated_query_with_rasterizer_discard: Bool32::default(), + primitives_generated_query_with_non_zero_streams: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; +} +impl PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + #[inline] + pub fn primitives_generated_query(mut self, primitives_generated_query: bool) -> Self { + self.inner.primitives_generated_query = primitives_generated_query.into(); + self + } + #[inline] + pub fn primitives_generated_query_with_rasterizer_discard( + mut self, + primitives_generated_query_with_rasterizer_discard: bool, + ) -> Self { + self.inner + .primitives_generated_query_with_rasterizer_discard = + primitives_generated_query_with_rasterizer_discard.into(); + self + } + #[inline] + pub fn primitives_generated_query_with_non_zero_streams( + mut self, + primitives_generated_query_with_non_zero_streams: bool, + ) -> Self { + self.inner.primitives_generated_query_with_non_zero_streams = + primitives_generated_query_with_non_zero_streams.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLegacyDitheringFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub legacy_dithering: Bool32, +} +impl ::std::default::Default for PhysicalDeviceLegacyDitheringFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + legacy_dithering: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceLegacyDitheringFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; +} +impl PhysicalDeviceLegacyDitheringFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + PhysicalDeviceLegacyDitheringFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceLegacyDitheringFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceLegacyDitheringFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + #[inline] + pub fn legacy_dithering(mut self, legacy_dithering: bool) -> Self { + self.inner.legacy_dithering = legacy_dithering.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLegacyDitheringFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multisampled_render_to_single_sampled: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multisampled_render_to_single_sampled: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; +} +impl PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> +{ + type Target = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + #[inline] + pub fn multisampled_render_to_single_sampled( + mut self, + multisampled_render_to_single_sampled: bool, + ) -> Self { + self.inner.multisampled_render_to_single_sampled = + multisampled_render_to_single_sampled.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassResolvePerformanceQueryEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub optimal: Bool32, +} +impl ::std::default::Default for SubpassResolvePerformanceQueryEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + optimal: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SubpassResolvePerformanceQueryEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; +} +impl SubpassResolvePerformanceQueryEXT { + pub fn builder<'a>() -> SubpassResolvePerformanceQueryEXTBuilder<'a> { + SubpassResolvePerformanceQueryEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassResolvePerformanceQueryEXTBuilder<'a> { + inner: SubpassResolvePerformanceQueryEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXT {} +impl<'a> ::std::ops::Deref for SubpassResolvePerformanceQueryEXTBuilder<'a> { + type Target = SubpassResolvePerformanceQueryEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassResolvePerformanceQueryEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassResolvePerformanceQueryEXTBuilder<'a> { + #[inline] + pub fn optimal(mut self, optimal: bool) -> Self { + self.inner.optimal = optimal.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassResolvePerformanceQueryEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MultisampledRenderToSingleSampledInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub multisampled_render_to_single_sampled_enable: Bool32, + pub rasterization_samples: SampleCountFlags, +} +impl ::std::default::Default for MultisampledRenderToSingleSampledInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + multisampled_render_to_single_sampled_enable: Bool32::default(), + rasterization_samples: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for MultisampledRenderToSingleSampledInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT; +} +impl MultisampledRenderToSingleSampledInfoEXT { + pub fn builder<'a>() -> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + MultisampledRenderToSingleSampledInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + inner: MultisampledRenderToSingleSampledInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXT {} +unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXT {} +impl<'a> ::std::ops::Deref for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + type Target = MultisampledRenderToSingleSampledInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + #[inline] + pub fn multisampled_render_to_single_sampled_enable( + mut self, + multisampled_render_to_single_sampled_enable: bool, + ) -> Self { + self.inner.multisampled_render_to_single_sampled_enable = + multisampled_render_to_single_sampled_enable.into(); + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultisampledRenderToSingleSampledInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_protected_access: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelineProtectedAccessFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_protected_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineProtectedAccessFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; +} +impl PhysicalDevicePipelineProtectedAccessFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePipelineProtectedAccessFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineProtectedAccessFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineProtectedAccessFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePipelineProtectedAccessFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + #[inline] + pub fn pipeline_protected_access(mut self, pipeline_protected_access: bool) -> Self { + self.inner.pipeline_protected_access = pipeline_protected_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineProtectedAccessFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyVideoPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub video_codec_operations: VideoCodecOperationFlagsKHR, +} +impl ::std::default::Default for QueueFamilyVideoPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + video_codec_operations: VideoCodecOperationFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyVideoPropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; +} +impl QueueFamilyVideoPropertiesKHR { + pub fn builder<'a>() -> QueueFamilyVideoPropertiesKHRBuilder<'a> { + QueueFamilyVideoPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyVideoPropertiesKHRBuilder<'a> { + inner: QueueFamilyVideoPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHRBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHR {} +impl<'a> ::std::ops::Deref for QueueFamilyVideoPropertiesKHRBuilder<'a> { + type Target = QueueFamilyVideoPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyVideoPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyVideoPropertiesKHRBuilder<'a> { + #[inline] + pub fn video_codec_operations( + mut self, + video_codec_operations: VideoCodecOperationFlagsKHR, + ) -> Self { + self.inner.video_codec_operations = video_codec_operations; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyVideoPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyQueryResultStatusPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub query_result_status_support: Bool32, +} +impl ::std::default::Default for QueueFamilyQueryResultStatusPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + query_result_status_support: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyQueryResultStatusPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; +} +impl QueueFamilyQueryResultStatusPropertiesKHR { + pub fn builder<'a>() -> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + QueueFamilyQueryResultStatusPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + inner: QueueFamilyQueryResultStatusPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHR {} +impl<'a> ::std::ops::Deref for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + type Target = QueueFamilyQueryResultStatusPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + #[inline] + pub fn query_result_status_support(mut self, query_result_status_support: bool) -> Self { + self.inner.query_result_status_support = query_result_status_support.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyQueryResultStatusPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoProfileListInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub profile_count: u32, + pub p_profiles: *const VideoProfileInfoKHR, +} +impl ::std::default::Default for VideoProfileListInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + profile_count: u32::default(), + p_profiles: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoProfileListInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PROFILE_LIST_INFO_KHR; +} +impl VideoProfileListInfoKHR { + pub fn builder<'a>() -> VideoProfileListInfoKHRBuilder<'a> { + VideoProfileListInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoProfileListInfoKHRBuilder<'a> { + inner: VideoProfileListInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHR {} +unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHR {} +unsafe impl ExtendsImageCreateInfo for VideoProfileListInfoKHRBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoProfileListInfoKHR {} +unsafe impl ExtendsBufferCreateInfo for VideoProfileListInfoKHRBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoProfileListInfoKHR {} +impl<'a> ::std::ops::Deref for VideoProfileListInfoKHRBuilder<'a> { + type Target = VideoProfileListInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoProfileListInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoProfileListInfoKHRBuilder<'a> { + #[inline] + pub fn profiles(mut self, profiles: &'a [VideoProfileInfoKHR]) -> Self { + self.inner.profile_count = profiles.len() as _; + self.inner.p_profiles = profiles.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoProfileListInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVideoFormatInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_usage: ImageUsageFlags, +} +impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_usage: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVideoFormatInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; +} +impl PhysicalDeviceVideoFormatInfoKHR { + pub fn builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + PhysicalDeviceVideoFormatInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + inner: PhysicalDeviceVideoFormatInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceVideoFormatInfoKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + type Target = PhysicalDeviceVideoFormatInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + #[inline] + pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self { + self.inner.image_usage = image_usage; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVideoFormatInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoFormatPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub component_mapping: ComponentMapping, + pub image_create_flags: ImageCreateFlags, + pub image_type: ImageType, + pub image_tiling: ImageTiling, + pub image_usage_flags: ImageUsageFlags, +} +impl ::std::default::Default for VideoFormatPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + component_mapping: ComponentMapping::default(), + image_create_flags: ImageCreateFlags::default(), + image_type: ImageType::default(), + image_tiling: ImageTiling::default(), + image_usage_flags: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for VideoFormatPropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_FORMAT_PROPERTIES_KHR; +} +impl VideoFormatPropertiesKHR { + pub fn builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a> { + VideoFormatPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoFormatPropertiesKHRBuilder<'a> { + inner: VideoFormatPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> { + type Target = VideoFormatPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoFormatPropertiesKHRBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn component_mapping(mut self, component_mapping: ComponentMapping) -> Self { + self.inner.component_mapping = component_mapping; + self + } + #[inline] + pub fn image_create_flags(mut self, image_create_flags: ImageCreateFlags) -> Self { + self.inner.image_create_flags = image_create_flags; + self + } + #[inline] + pub fn image_type(mut self, image_type: ImageType) -> Self { + self.inner.image_type = image_type; + self + } + #[inline] + pub fn image_tiling(mut self, image_tiling: ImageTiling) -> Self { + self.inner.image_tiling = image_tiling; + self + } + #[inline] + pub fn image_usage_flags(mut self, image_usage_flags: ImageUsageFlags) -> Self { + self.inner.image_usage_flags = image_usage_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoFormatPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoProfileInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub video_codec_operation: VideoCodecOperationFlagsKHR, + pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR, + pub luma_bit_depth: VideoComponentBitDepthFlagsKHR, + pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR, +} +impl ::std::default::Default for VideoProfileInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + video_codec_operation: VideoCodecOperationFlagsKHR::default(), + chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(), + luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(), + chroma_bit_depth: VideoComponentBitDepthFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoProfileInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PROFILE_INFO_KHR; +} +impl VideoProfileInfoKHR { + pub fn builder<'a>() -> VideoProfileInfoKHRBuilder<'a> { + VideoProfileInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoProfileInfoKHRBuilder<'a> { + inner: VideoProfileInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHR {} +pub unsafe trait ExtendsVideoProfileInfoKHR {} +impl<'a> ::std::ops::Deref for VideoProfileInfoKHRBuilder<'a> { + type Target = VideoProfileInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoProfileInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoProfileInfoKHRBuilder<'a> { + #[inline] + pub fn video_codec_operation( + mut self, + video_codec_operation: VideoCodecOperationFlagsKHR, + ) -> Self { + self.inner.video_codec_operation = video_codec_operation; + self + } + #[inline] + pub fn chroma_subsampling( + mut self, + chroma_subsampling: VideoChromaSubsamplingFlagsKHR, + ) -> Self { + self.inner.chroma_subsampling = chroma_subsampling; + self + } + #[inline] + pub fn luma_bit_depth(mut self, luma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self { + self.inner.luma_bit_depth = luma_bit_depth; + self + } + #[inline] + pub fn chroma_bit_depth(mut self, chroma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self { + self.inner.chroma_bit_depth = chroma_bit_depth; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoProfileInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoCapabilityFlagsKHR, + pub min_bitstream_buffer_offset_alignment: DeviceSize, + pub min_bitstream_buffer_size_alignment: DeviceSize, + pub picture_access_granularity: Extent2D, + pub min_coded_extent: Extent2D, + pub max_coded_extent: Extent2D, + pub max_dpb_slots: u32, + pub max_active_reference_pictures: u32, + pub std_header_version: ExtensionProperties, +} +impl ::std::default::Default for VideoCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoCapabilityFlagsKHR::default(), + min_bitstream_buffer_offset_alignment: DeviceSize::default(), + min_bitstream_buffer_size_alignment: DeviceSize::default(), + picture_access_granularity: Extent2D::default(), + min_coded_extent: Extent2D::default(), + max_coded_extent: Extent2D::default(), + max_dpb_slots: u32::default(), + max_active_reference_pictures: u32::default(), + std_header_version: ExtensionProperties::default(), + } + } +} +unsafe impl TaggedStructure for VideoCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_CAPABILITIES_KHR; +} +impl VideoCapabilitiesKHR { + pub fn builder<'a>() -> VideoCapabilitiesKHRBuilder<'a> { + VideoCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoCapabilitiesKHRBuilder<'a> { + inner: VideoCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoCapabilitiesKHRBuilder<'a> { + type Target = VideoCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoCapabilityFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn min_bitstream_buffer_offset_alignment( + mut self, + min_bitstream_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment; + self + } + #[inline] + pub fn min_bitstream_buffer_size_alignment( + mut self, + min_bitstream_buffer_size_alignment: DeviceSize, + ) -> Self { + self.inner.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment; + self + } + #[inline] + pub fn picture_access_granularity(mut self, picture_access_granularity: Extent2D) -> Self { + self.inner.picture_access_granularity = picture_access_granularity; + self + } + #[inline] + pub fn min_coded_extent(mut self, min_coded_extent: Extent2D) -> Self { + self.inner.min_coded_extent = min_coded_extent; + self + } + #[inline] + pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self { + self.inner.max_coded_extent = max_coded_extent; + self + } + #[inline] + pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self { + self.inner.max_dpb_slots = max_dpb_slots; + self + } + #[inline] + pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self { + self.inner.max_active_reference_pictures = max_active_reference_pictures; + self + } + #[inline] + pub fn std_header_version(mut self, std_header_version: ExtensionProperties) -> Self { + self.inner.std_header_version = std_header_version; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoSessionMemoryRequirementsKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_bind_index: u32, + pub memory_requirements: MemoryRequirements, +} +impl ::std::default::Default for VideoSessionMemoryRequirementsKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_bind_index: u32::default(), + memory_requirements: MemoryRequirements::default(), + } + } +} +unsafe impl TaggedStructure for VideoSessionMemoryRequirementsKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR; +} +impl VideoSessionMemoryRequirementsKHR { + pub fn builder<'a>() -> VideoSessionMemoryRequirementsKHRBuilder<'a> { + VideoSessionMemoryRequirementsKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoSessionMemoryRequirementsKHRBuilder<'a> { + inner: VideoSessionMemoryRequirementsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoSessionMemoryRequirementsKHRBuilder<'a> { + type Target = VideoSessionMemoryRequirementsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoSessionMemoryRequirementsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoSessionMemoryRequirementsKHRBuilder<'a> { + #[inline] + pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self { + self.inner.memory_bind_index = memory_bind_index; + self + } + #[inline] + pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self { + self.inner.memory_requirements = memory_requirements; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoSessionMemoryRequirementsKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindVideoSessionMemoryInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory_bind_index: u32, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub memory_size: DeviceSize, +} +impl ::std::default::Default for BindVideoSessionMemoryInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory_bind_index: u32::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + memory_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BindVideoSessionMemoryInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_VIDEO_SESSION_MEMORY_INFO_KHR; +} +impl BindVideoSessionMemoryInfoKHR { + pub fn builder<'a>() -> BindVideoSessionMemoryInfoKHRBuilder<'a> { + BindVideoSessionMemoryInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindVideoSessionMemoryInfoKHRBuilder<'a> { + inner: BindVideoSessionMemoryInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindVideoSessionMemoryInfoKHRBuilder<'a> { + type Target = BindVideoSessionMemoryInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindVideoSessionMemoryInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindVideoSessionMemoryInfoKHRBuilder<'a> { + #[inline] + pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self { + self.inner.memory_bind_index = memory_bind_index; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[inline] + pub fn memory_size(mut self, memory_size: DeviceSize) -> Self { + self.inner.memory_size = memory_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindVideoSessionMemoryInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoPictureResourceInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub coded_offset: Offset2D, + pub coded_extent: Extent2D, + pub base_array_layer: u32, + pub image_view_binding: ImageView, +} +impl ::std::default::Default for VideoPictureResourceInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + coded_offset: Offset2D::default(), + coded_extent: Extent2D::default(), + base_array_layer: u32::default(), + image_view_binding: ImageView::default(), + } + } +} +unsafe impl TaggedStructure for VideoPictureResourceInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PICTURE_RESOURCE_INFO_KHR; +} +impl VideoPictureResourceInfoKHR { + pub fn builder<'a>() -> VideoPictureResourceInfoKHRBuilder<'a> { + VideoPictureResourceInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoPictureResourceInfoKHRBuilder<'a> { + inner: VideoPictureResourceInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoPictureResourceInfoKHRBuilder<'a> { + type Target = VideoPictureResourceInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoPictureResourceInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoPictureResourceInfoKHRBuilder<'a> { + #[inline] + pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self { + self.inner.coded_offset = coded_offset; + self + } + #[inline] + pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self { + self.inner.coded_extent = coded_extent; + self + } + #[inline] + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.inner.base_array_layer = base_array_layer; + self + } + #[inline] + pub fn image_view_binding(mut self, image_view_binding: ImageView) -> Self { + self.inner.image_view_binding = image_view_binding; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoPictureResourceInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoReferenceSlotInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub slot_index: i32, + pub p_picture_resource: *const VideoPictureResourceInfoKHR, +} +impl ::std::default::Default for VideoReferenceSlotInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + slot_index: i32::default(), + p_picture_resource: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoReferenceSlotInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_REFERENCE_SLOT_INFO_KHR; +} +impl VideoReferenceSlotInfoKHR { + pub fn builder<'a>() -> VideoReferenceSlotInfoKHRBuilder<'a> { + VideoReferenceSlotInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoReferenceSlotInfoKHRBuilder<'a> { + inner: VideoReferenceSlotInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoReferenceSlotInfoKHR {} +impl<'a> ::std::ops::Deref for VideoReferenceSlotInfoKHRBuilder<'a> { + type Target = VideoReferenceSlotInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoReferenceSlotInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoReferenceSlotInfoKHRBuilder<'a> { + #[inline] + pub fn slot_index(mut self, slot_index: i32) -> Self { + self.inner.slot_index = slot_index; + self + } + #[inline] + pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceInfoKHR) -> Self { + self.inner.p_picture_resource = picture_resource; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoReferenceSlotInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoDecodeCapabilityFlagsKHR, +} +impl ::std::default::Default for VideoDecodeCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoDecodeCapabilityFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_CAPABILITIES_KHR; +} +impl VideoDecodeCapabilitiesKHR { + pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> { + VideoDecodeCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeCapabilitiesKHRBuilder<'a> { + inner: VideoDecodeCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> { + type Target = VideoDecodeCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeUsageInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub video_usage_hints: VideoDecodeUsageFlagsKHR, +} +impl ::std::default::Default for VideoDecodeUsageInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + video_usage_hints: VideoDecodeUsageFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeUsageInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_USAGE_INFO_KHR; +} +impl VideoDecodeUsageInfoKHR { + pub fn builder<'a>() -> VideoDecodeUsageInfoKHRBuilder<'a> { + VideoDecodeUsageInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeUsageInfoKHRBuilder<'a> { + inner: VideoDecodeUsageInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeUsageInfoKHRBuilder<'a> { + type Target = VideoDecodeUsageInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeUsageInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeUsageInfoKHRBuilder<'a> { + #[inline] + pub fn video_usage_hints(mut self, video_usage_hints: VideoDecodeUsageFlagsKHR) -> Self { + self.inner.video_usage_hints = video_usage_hints; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeUsageInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoDecodeFlagsKHR, + pub src_buffer: Buffer, + pub src_buffer_offset: DeviceSize, + pub src_buffer_range: DeviceSize, + pub dst_picture_resource: VideoPictureResourceInfoKHR, + pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR, + pub reference_slot_count: u32, + pub p_reference_slots: *const VideoReferenceSlotInfoKHR, +} +impl ::std::default::Default for VideoDecodeInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoDecodeFlagsKHR::default(), + src_buffer: Buffer::default(), + src_buffer_offset: DeviceSize::default(), + src_buffer_range: DeviceSize::default(), + dst_picture_resource: VideoPictureResourceInfoKHR::default(), + p_setup_reference_slot: ::std::ptr::null(), + reference_slot_count: u32::default(), + p_reference_slots: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_INFO_KHR; +} +impl VideoDecodeInfoKHR { + pub fn builder<'a>() -> VideoDecodeInfoKHRBuilder<'a> { + VideoDecodeInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeInfoKHRBuilder<'a> { + inner: VideoDecodeInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoDecodeInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeInfoKHRBuilder<'a> { + type Target = VideoDecodeInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoDecodeFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { + self.inner.src_buffer = src_buffer; + self + } + #[inline] + pub fn src_buffer_offset(mut self, src_buffer_offset: DeviceSize) -> Self { + self.inner.src_buffer_offset = src_buffer_offset; + self + } + #[inline] + pub fn src_buffer_range(mut self, src_buffer_range: DeviceSize) -> Self { + self.inner.src_buffer_range = src_buffer_range; + self + } + #[inline] + pub fn dst_picture_resource( + mut self, + dst_picture_resource: VideoPictureResourceInfoKHR, + ) -> Self { + self.inner.dst_picture_resource = dst_picture_resource; + self + } + #[inline] + pub fn setup_reference_slot( + mut self, + setup_reference_slot: &'a VideoReferenceSlotInfoKHR, + ) -> Self { + self.inner.p_setup_reference_slot = setup_reference_slot; + self + } + #[inline] + pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self { + self.inner.reference_slot_count = reference_slots.len() as _; + self.inner.p_reference_slots = reference_slots.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264ProfileInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH264ProfileIdc, + pub picture_layout: VideoDecodeH264PictureLayoutFlagsKHR, +} +impl ::std::default::Default for VideoDecodeH264ProfileInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH264ProfileIdc::default(), + picture_layout: VideoDecodeH264PictureLayoutFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264ProfileInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PROFILE_INFO_KHR; +} +impl VideoDecodeH264ProfileInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264ProfileInfoKHRBuilder<'a> { + VideoDecodeH264ProfileInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264ProfileInfoKHRBuilder<'a> { + inner: VideoDecodeH264ProfileInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileInfoKHRBuilder<'a> { + type Target = VideoDecodeH264ProfileInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264ProfileInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264ProfileInfoKHRBuilder<'a> { + #[inline] + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[inline] + pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsKHR) -> Self { + self.inner.picture_layout = picture_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264ProfileInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264CapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_level_idc: StdVideoH264LevelIdc, + pub field_offset_granularity: Offset2D, +} +impl ::std::default::Default for VideoDecodeH264CapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_level_idc: StdVideoH264LevelIdc::default(), + field_offset_granularity: Offset2D::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264CapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_CAPABILITIES_KHR; +} +impl VideoDecodeH264CapabilitiesKHR { + pub fn builder<'a>() -> VideoDecodeH264CapabilitiesKHRBuilder<'a> { + VideoDecodeH264CapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264CapabilitiesKHRBuilder<'a> { + inner: VideoDecodeH264CapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesKHRBuilder<'a> { + type Target = VideoDecodeH264CapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264CapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264CapabilitiesKHRBuilder<'a> { + #[inline] + pub fn max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self { + self.inner.max_level_idc = max_level_idc; + self + } + #[inline] + pub fn field_offset_granularity(mut self, field_offset_granularity: Offset2D) -> Self { + self.inner.field_offset_granularity = field_offset_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264CapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264SessionParametersAddInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH264PictureParameterSet, +} +impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264SessionParametersAddInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; +} +impl VideoDecodeH264SessionParametersAddInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + VideoDecodeH264SessionParametersAddInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + inner: VideoDecodeH264SessionParametersAddInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoDecodeH264SessionParametersAddInfoKHR +{ +} +impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + type Target = VideoDecodeH264SessionParametersAddInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + #[inline] + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self { + self.inner.std_sps_count = std_sp_ss.len() as _; + self.inner.p_std_sp_ss = std_sp_ss.as_ptr(); + self + } + #[inline] + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self { + self.inner.std_pps_count = std_pp_ss.len() as _; + self.inner.p_std_pp_ss = std_pp_ss.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264SessionParametersAddInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264SessionParametersCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, + pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoKHR, +} +impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264SessionParametersCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +impl VideoDecodeH264SessionParametersCreateInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + VideoDecodeH264SessionParametersCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + inner: VideoDecodeH264SessionParametersCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoDecodeH264SessionParametersCreateInfoKHR +{ +} +impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + type Target = VideoDecodeH264SessionParametersCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + #[inline] + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.inner.max_std_sps_count = max_std_sps_count; + self + } + #[inline] + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.inner.max_std_pps_count = max_std_pps_count; + self + } + #[inline] + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoKHR, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264SessionParametersCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264PictureInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo, + pub slice_count: u32, + pub p_slice_offsets: *const u32, +} +impl ::std::default::Default for VideoDecodeH264PictureInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_std_picture_info: ::std::ptr::null(), + slice_count: u32::default(), + p_slice_offsets: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264PictureInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PICTURE_INFO_KHR; +} +impl VideoDecodeH264PictureInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264PictureInfoKHRBuilder<'a> { + VideoDecodeH264PictureInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264PictureInfoKHRBuilder<'a> { + inner: VideoDecodeH264PictureInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoKHRBuilder<'a> { + type Target = VideoDecodeH264PictureInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264PictureInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264PictureInfoKHRBuilder<'a> { + #[inline] + pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self { + self.inner.p_std_picture_info = std_picture_info; + self + } + #[inline] + pub fn slice_offsets(mut self, slice_offsets: &'a [u32]) -> Self { + self.inner.slice_count = slice_offsets.len() as _; + self.inner.p_slice_offsets = slice_offsets.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264PictureInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264DpbSlotInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_std_reference_info: *const StdVideoDecodeH264ReferenceInfo, +} +impl ::std::default::Default for VideoDecodeH264DpbSlotInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264DpbSlotInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; +} +impl VideoDecodeH264DpbSlotInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + VideoDecodeH264DpbSlotInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + inner: VideoDecodeH264DpbSlotInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + type Target = VideoDecodeH264DpbSlotInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + #[inline] + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoDecodeH264ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264DpbSlotInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265ProfileInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH265ProfileIdc, +} +impl ::std::default::Default for VideoDecodeH265ProfileInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH265ProfileIdc::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265ProfileInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PROFILE_INFO_KHR; +} +impl VideoDecodeH265ProfileInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265ProfileInfoKHRBuilder<'a> { + VideoDecodeH265ProfileInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265ProfileInfoKHRBuilder<'a> { + inner: VideoDecodeH265ProfileInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileInfoKHRBuilder<'a> { + type Target = VideoDecodeH265ProfileInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265ProfileInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265ProfileInfoKHRBuilder<'a> { + #[inline] + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265ProfileInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265CapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_level_idc: StdVideoH265LevelIdc, +} +impl ::std::default::Default for VideoDecodeH265CapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_level_idc: StdVideoH265LevelIdc::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265CapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_CAPABILITIES_KHR; +} +impl VideoDecodeH265CapabilitiesKHR { + pub fn builder<'a>() -> VideoDecodeH265CapabilitiesKHRBuilder<'a> { + VideoDecodeH265CapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265CapabilitiesKHRBuilder<'a> { + inner: VideoDecodeH265CapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesKHRBuilder<'a> { + type Target = VideoDecodeH265CapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265CapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265CapabilitiesKHRBuilder<'a> { + #[inline] + pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self { + self.inner.max_level_idc = max_level_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265CapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265SessionParametersAddInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_vps_count: u32, + pub p_std_vp_ss: *const StdVideoH265VideoParameterSet, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH265PictureParameterSet, +} +impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_vps_count: u32::default(), + p_std_vp_ss: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265SessionParametersAddInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; +} +impl VideoDecodeH265SessionParametersAddInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + VideoDecodeH265SessionParametersAddInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + inner: VideoDecodeH265SessionParametersAddInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoDecodeH265SessionParametersAddInfoKHR +{ +} +impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + type Target = VideoDecodeH265SessionParametersAddInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + #[inline] + pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self { + self.inner.std_vps_count = std_vp_ss.len() as _; + self.inner.p_std_vp_ss = std_vp_ss.as_ptr(); + self + } + #[inline] + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self { + self.inner.std_sps_count = std_sp_ss.len() as _; + self.inner.p_std_sp_ss = std_sp_ss.as_ptr(); + self + } + #[inline] + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self { + self.inner.std_pps_count = std_pp_ss.len() as _; + self.inner.p_std_pp_ss = std_pp_ss.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265SessionParametersAddInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265SessionParametersCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_std_vps_count: u32, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, + pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoKHR, +} +impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_std_vps_count: u32::default(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265SessionParametersCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +impl VideoDecodeH265SessionParametersCreateInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + VideoDecodeH265SessionParametersCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + inner: VideoDecodeH265SessionParametersCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoDecodeH265SessionParametersCreateInfoKHR +{ +} +impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + type Target = VideoDecodeH265SessionParametersCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + #[inline] + pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { + self.inner.max_std_vps_count = max_std_vps_count; + self + } + #[inline] + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.inner.max_std_sps_count = max_std_sps_count; + self + } + #[inline] + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.inner.max_std_pps_count = max_std_pps_count; + self + } + #[inline] + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoKHR, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265SessionParametersCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265PictureInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo, + pub slice_segment_count: u32, + pub p_slice_segment_offsets: *const u32, +} +impl ::std::default::Default for VideoDecodeH265PictureInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_std_picture_info: ::std::ptr::null_mut(), + slice_segment_count: u32::default(), + p_slice_segment_offsets: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265PictureInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PICTURE_INFO_KHR; +} +impl VideoDecodeH265PictureInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265PictureInfoKHRBuilder<'a> { + VideoDecodeH265PictureInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265PictureInfoKHRBuilder<'a> { + inner: VideoDecodeH265PictureInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH265PictureInfoKHRBuilder<'a> { + type Target = VideoDecodeH265PictureInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265PictureInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265PictureInfoKHRBuilder<'a> { + #[inline] + pub fn std_picture_info( + mut self, + std_picture_info: &'a mut StdVideoDecodeH265PictureInfo, + ) -> Self { + self.inner.p_std_picture_info = std_picture_info; + self + } + #[inline] + pub fn slice_segment_offsets(mut self, slice_segment_offsets: &'a [u32]) -> Self { + self.inner.slice_segment_count = slice_segment_offsets.len() as _; + self.inner.p_slice_segment_offsets = slice_segment_offsets.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265PictureInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265DpbSlotInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_std_reference_info: *const StdVideoDecodeH265ReferenceInfo, +} +impl ::std::default::Default for VideoDecodeH265DpbSlotInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265DpbSlotInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; +} +impl VideoDecodeH265DpbSlotInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + VideoDecodeH265DpbSlotInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + inner: VideoDecodeH265DpbSlotInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + type Target = VideoDecodeH265DpbSlotInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + #[inline] + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoDecodeH265ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265DpbSlotInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoSessionCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue_family_index: u32, + pub flags: VideoSessionCreateFlagsKHR, + pub p_video_profile: *const VideoProfileInfoKHR, + pub picture_format: Format, + pub max_coded_extent: Extent2D, + pub reference_picture_format: Format, + pub max_dpb_slots: u32, + pub max_active_reference_pictures: u32, + pub p_std_header_version: *const ExtensionProperties, +} +impl ::std::default::Default for VideoSessionCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + queue_family_index: u32::default(), + flags: VideoSessionCreateFlagsKHR::default(), + p_video_profile: ::std::ptr::null(), + picture_format: Format::default(), + max_coded_extent: Extent2D::default(), + reference_picture_format: Format::default(), + max_dpb_slots: u32::default(), + max_active_reference_pictures: u32::default(), + p_std_header_version: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoSessionCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_CREATE_INFO_KHR; +} +impl VideoSessionCreateInfoKHR { + pub fn builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a> { + VideoSessionCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoSessionCreateInfoKHRBuilder<'a> { + inner: VideoSessionCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> { + type Target = VideoSessionCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoSessionCreateInfoKHRBuilder<'a> { + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[inline] + pub fn flags(mut self, flags: VideoSessionCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn video_profile(mut self, video_profile: &'a VideoProfileInfoKHR) -> Self { + self.inner.p_video_profile = video_profile; + self + } + #[inline] + pub fn picture_format(mut self, picture_format: Format) -> Self { + self.inner.picture_format = picture_format; + self + } + #[inline] + pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self { + self.inner.max_coded_extent = max_coded_extent; + self + } + #[inline] + pub fn reference_picture_format(mut self, reference_picture_format: Format) -> Self { + self.inner.reference_picture_format = reference_picture_format; + self + } + #[inline] + pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self { + self.inner.max_dpb_slots = max_dpb_slots; + self + } + #[inline] + pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self { + self.inner.max_active_reference_pictures = max_active_reference_pictures; + self + } + #[inline] + pub fn std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self { + self.inner.p_std_header_version = std_header_version; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoSessionCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoSessionParametersCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoSessionParametersCreateFlagsKHR, + pub video_session_parameters_template: VideoSessionParametersKHR, + pub video_session: VideoSessionKHR, +} +impl ::std::default::Default for VideoSessionParametersCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoSessionParametersCreateFlagsKHR::default(), + video_session_parameters_template: VideoSessionParametersKHR::default(), + video_session: VideoSessionKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoSessionParametersCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +impl VideoSessionParametersCreateInfoKHR { + pub fn builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a> { + VideoSessionParametersCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoSessionParametersCreateInfoKHRBuilder<'a> { + inner: VideoSessionParametersCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoSessionParametersCreateInfoKHR {} +impl<'a> ::std::ops::Deref for VideoSessionParametersCreateInfoKHRBuilder<'a> { + type Target = VideoSessionParametersCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoSessionParametersCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn video_session_parameters_template( + mut self, + video_session_parameters_template: VideoSessionParametersKHR, + ) -> Self { + self.inner.video_session_parameters_template = video_session_parameters_template; + self + } + #[inline] + pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self { + self.inner.video_session = video_session; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoSessionParametersCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoSessionParametersUpdateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub update_sequence_count: u32, +} +impl ::std::default::Default for VideoSessionParametersUpdateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + update_sequence_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for VideoSessionParametersUpdateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; +} +impl VideoSessionParametersUpdateInfoKHR { + pub fn builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> { + VideoSessionParametersUpdateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoSessionParametersUpdateInfoKHRBuilder<'a> { + inner: VideoSessionParametersUpdateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoSessionParametersUpdateInfoKHR {} +impl<'a> ::std::ops::Deref for VideoSessionParametersUpdateInfoKHRBuilder<'a> { + type Target = VideoSessionParametersUpdateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> { + #[inline] + pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self { + self.inner.update_sequence_count = update_sequence_count; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoSessionParametersUpdateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoBeginCodingInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoBeginCodingFlagsKHR, + pub video_session: VideoSessionKHR, + pub video_session_parameters: VideoSessionParametersKHR, + pub reference_slot_count: u32, + pub p_reference_slots: *const VideoReferenceSlotInfoKHR, +} +impl ::std::default::Default for VideoBeginCodingInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoBeginCodingFlagsKHR::default(), + video_session: VideoSessionKHR::default(), + video_session_parameters: VideoSessionParametersKHR::default(), + reference_slot_count: u32::default(), + p_reference_slots: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoBeginCodingInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_BEGIN_CODING_INFO_KHR; +} +impl VideoBeginCodingInfoKHR { + pub fn builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a> { + VideoBeginCodingInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoBeginCodingInfoKHRBuilder<'a> { + inner: VideoBeginCodingInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> { + type Target = VideoBeginCodingInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoBeginCodingInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self { + self.inner.video_session = video_session; + self + } + #[inline] + pub fn video_session_parameters( + mut self, + video_session_parameters: VideoSessionParametersKHR, + ) -> Self { + self.inner.video_session_parameters = video_session_parameters; + self + } + #[inline] + pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self { + self.inner.reference_slot_count = reference_slots.len() as _; + self.inner.p_reference_slots = reference_slots.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoBeginCodingInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEndCodingInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoEndCodingFlagsKHR, +} +impl ::std::default::Default for VideoEndCodingInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoEndCodingFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoEndCodingInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_END_CODING_INFO_KHR; +} +impl VideoEndCodingInfoKHR { + pub fn builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a> { + VideoEndCodingInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEndCodingInfoKHRBuilder<'a> { + inner: VideoEndCodingInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> { + type Target = VideoEndCodingInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEndCodingInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEndCodingFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEndCodingInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoCodingControlInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoCodingControlFlagsKHR, +} +impl ::std::default::Default for VideoCodingControlInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoCodingControlFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoCodingControlInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_CODING_CONTROL_INFO_KHR; +} +impl VideoCodingControlInfoKHR { + pub fn builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a> { + VideoCodingControlInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoCodingControlInfoKHRBuilder<'a> { + inner: VideoCodingControlInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoCodingControlInfoKHR {} +impl<'a> ::std::ops::Deref for VideoCodingControlInfoKHRBuilder<'a> { + type Target = VideoCodingControlInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoCodingControlInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoCodingControlFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoCodingControlInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeUsageInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub video_usage_hints: VideoEncodeUsageFlagsKHR, + pub video_content_hints: VideoEncodeContentFlagsKHR, + pub tuning_mode: VideoEncodeTuningModeKHR, +} +impl ::std::default::Default for VideoEncodeUsageInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + video_usage_hints: VideoEncodeUsageFlagsKHR::default(), + video_content_hints: VideoEncodeContentFlagsKHR::default(), + tuning_mode: VideoEncodeTuningModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeUsageInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_USAGE_INFO_KHR; +} +impl VideoEncodeUsageInfoKHR { + pub fn builder<'a>() -> VideoEncodeUsageInfoKHRBuilder<'a> { + VideoEncodeUsageInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeUsageInfoKHRBuilder<'a> { + inner: VideoEncodeUsageInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeUsageInfoKHRBuilder<'a> { + type Target = VideoEncodeUsageInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeUsageInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeUsageInfoKHRBuilder<'a> { + #[inline] + pub fn video_usage_hints(mut self, video_usage_hints: VideoEncodeUsageFlagsKHR) -> Self { + self.inner.video_usage_hints = video_usage_hints; + self + } + #[inline] + pub fn video_content_hints(mut self, video_content_hints: VideoEncodeContentFlagsKHR) -> Self { + self.inner.video_content_hints = video_content_hints; + self + } + #[inline] + pub fn tuning_mode(mut self, tuning_mode: VideoEncodeTuningModeKHR) -> Self { + self.inner.tuning_mode = tuning_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeUsageInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoEncodeFlagsKHR, + pub quality_level: u32, + pub dst_bitstream_buffer: Buffer, + pub dst_bitstream_buffer_offset: DeviceSize, + pub dst_bitstream_buffer_max_range: DeviceSize, + pub src_picture_resource: VideoPictureResourceInfoKHR, + pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR, + pub reference_slot_count: u32, + pub p_reference_slots: *const VideoReferenceSlotInfoKHR, + pub preceding_externally_encoded_bytes: u32, +} +impl ::std::default::Default for VideoEncodeInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoEncodeFlagsKHR::default(), + quality_level: u32::default(), + dst_bitstream_buffer: Buffer::default(), + dst_bitstream_buffer_offset: DeviceSize::default(), + dst_bitstream_buffer_max_range: DeviceSize::default(), + src_picture_resource: VideoPictureResourceInfoKHR::default(), + p_setup_reference_slot: ::std::ptr::null(), + reference_slot_count: u32::default(), + p_reference_slots: ::std::ptr::null(), + preceding_externally_encoded_bytes: u32::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_INFO_KHR; +} +impl VideoEncodeInfoKHR { + pub fn builder<'a>() -> VideoEncodeInfoKHRBuilder<'a> { + VideoEncodeInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeInfoKHRBuilder<'a> { + inner: VideoEncodeInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoEncodeInfoKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeInfoKHRBuilder<'a> { + type Target = VideoEncodeInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn quality_level(mut self, quality_level: u32) -> Self { + self.inner.quality_level = quality_level; + self + } + #[inline] + pub fn dst_bitstream_buffer(mut self, dst_bitstream_buffer: Buffer) -> Self { + self.inner.dst_bitstream_buffer = dst_bitstream_buffer; + self + } + #[inline] + pub fn dst_bitstream_buffer_offset(mut self, dst_bitstream_buffer_offset: DeviceSize) -> Self { + self.inner.dst_bitstream_buffer_offset = dst_bitstream_buffer_offset; + self + } + #[inline] + pub fn dst_bitstream_buffer_max_range( + mut self, + dst_bitstream_buffer_max_range: DeviceSize, + ) -> Self { + self.inner.dst_bitstream_buffer_max_range = dst_bitstream_buffer_max_range; + self + } + #[inline] + pub fn src_picture_resource( + mut self, + src_picture_resource: VideoPictureResourceInfoKHR, + ) -> Self { + self.inner.src_picture_resource = src_picture_resource; + self + } + #[inline] + pub fn setup_reference_slot( + mut self, + setup_reference_slot: &'a VideoReferenceSlotInfoKHR, + ) -> Self { + self.inner.p_setup_reference_slot = setup_reference_slot; + self + } + #[inline] + pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self { + self.inner.reference_slot_count = reference_slots.len() as _; + self.inner.p_reference_slots = reference_slots.as_ptr(); + self + } + #[inline] + pub fn preceding_externally_encoded_bytes( + mut self, + preceding_externally_encoded_bytes: u32, + ) -> Self { + self.inner.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeRateControlInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoEncodeRateControlFlagsKHR, + pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR, + pub layer_count: u8, + pub p_layer_configs: *const VideoEncodeRateControlLayerInfoKHR, +} +impl ::std::default::Default for VideoEncodeRateControlInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoEncodeRateControlFlagsKHR::default(), + rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(), + layer_count: u8::default(), + p_layer_configs: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeRateControlInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; +} +impl VideoEncodeRateControlInfoKHR { + pub fn builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a> { + VideoEncodeRateControlInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeRateControlInfoKHRBuilder<'a> { + inner: VideoEncodeRateControlInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeRateControlInfoKHRBuilder<'a> { + type Target = VideoEncodeRateControlInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn rate_control_mode( + mut self, + rate_control_mode: VideoEncodeRateControlModeFlagsKHR, + ) -> Self { + self.inner.rate_control_mode = rate_control_mode; + self + } + #[inline] + pub fn layer_configs( + mut self, + layer_configs: &'a [VideoEncodeRateControlLayerInfoKHR], + ) -> Self { + self.inner.layer_count = layer_configs.len() as _; + self.inner.p_layer_configs = layer_configs.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeRateControlInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeRateControlLayerInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub average_bitrate: u32, + pub max_bitrate: u32, + pub frame_rate_numerator: u32, + pub frame_rate_denominator: u32, + pub virtual_buffer_size_in_ms: u32, + pub initial_virtual_buffer_size_in_ms: u32, +} +impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + average_bitrate: u32::default(), + max_bitrate: u32::default(), + frame_rate_numerator: u32::default(), + frame_rate_denominator: u32::default(), + virtual_buffer_size_in_ms: u32::default(), + initial_virtual_buffer_size_in_ms: u32::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeRateControlLayerInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR; +} +impl VideoEncodeRateControlLayerInfoKHR { + pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + VideoEncodeRateControlLayerInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + inner: VideoEncodeRateControlLayerInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR {} +pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + type Target = VideoEncodeRateControlLayerInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + #[inline] + pub fn average_bitrate(mut self, average_bitrate: u32) -> Self { + self.inner.average_bitrate = average_bitrate; + self + } + #[inline] + pub fn max_bitrate(mut self, max_bitrate: u32) -> Self { + self.inner.max_bitrate = max_bitrate; + self + } + #[inline] + pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self { + self.inner.frame_rate_numerator = frame_rate_numerator; + self + } + #[inline] + pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self { + self.inner.frame_rate_denominator = frame_rate_denominator; + self + } + #[inline] + pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self { + self.inner.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms; + self + } + #[inline] + pub fn initial_virtual_buffer_size_in_ms( + mut self, + initial_virtual_buffer_size_in_ms: u32, + ) -> Self { + self.inner.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeRateControlLayerInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoEncodeCapabilityFlagsKHR, + pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR, + pub rate_control_layer_count: u8, + pub quality_level_count: u8, + pub input_image_data_fill_alignment: Extent2D, +} +impl ::std::default::Default for VideoEncodeCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoEncodeCapabilityFlagsKHR::default(), + rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(), + rate_control_layer_count: u8::default(), + quality_level_count: u8::default(), + input_image_data_fill_alignment: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_CAPABILITIES_KHR; +} +impl VideoEncodeCapabilitiesKHR { + pub fn builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a> { + VideoEncodeCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeCapabilitiesKHRBuilder<'a> { + inner: VideoEncodeCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeCapabilitiesKHRBuilder<'a> { + type Target = VideoEncodeCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeCapabilityFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn rate_control_modes( + mut self, + rate_control_modes: VideoEncodeRateControlModeFlagsKHR, + ) -> Self { + self.inner.rate_control_modes = rate_control_modes; + self + } + #[inline] + pub fn rate_control_layer_count(mut self, rate_control_layer_count: u8) -> Self { + self.inner.rate_control_layer_count = rate_control_layer_count; + self + } + #[inline] + pub fn quality_level_count(mut self, quality_level_count: u8) -> Self { + self.inner.quality_level_count = quality_level_count; + self + } + #[inline] + pub fn input_image_data_fill_alignment( + mut self, + input_image_data_fill_alignment: Extent2D, + ) -> Self { + self.inner.input_image_data_fill_alignment = input_image_data_fill_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264CapabilitiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoEncodeH264CapabilityFlagsEXT, + pub input_mode_flags: VideoEncodeH264InputModeFlagsEXT, + pub output_mode_flags: VideoEncodeH264OutputModeFlagsEXT, + pub max_p_picture_l0_reference_count: u8, + pub max_b_picture_l0_reference_count: u8, + pub max_l1_reference_count: u8, + pub motion_vectors_over_pic_boundaries_flag: Bool32, + pub max_bytes_per_pic_denom: u32, + pub max_bits_per_mb_denom: u32, + pub log2_max_mv_length_horizontal: u32, + pub log2_max_mv_length_vertical: u32, +} +impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoEncodeH264CapabilityFlagsEXT::default(), + input_mode_flags: VideoEncodeH264InputModeFlagsEXT::default(), + output_mode_flags: VideoEncodeH264OutputModeFlagsEXT::default(), + max_p_picture_l0_reference_count: u8::default(), + max_b_picture_l0_reference_count: u8::default(), + max_l1_reference_count: u8::default(), + motion_vectors_over_pic_boundaries_flag: Bool32::default(), + max_bytes_per_pic_denom: u32::default(), + max_bits_per_mb_denom: u32::default(), + log2_max_mv_length_horizontal: u32::default(), + log2_max_mv_length_vertical: u32::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264CapabilitiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_CAPABILITIES_EXT; +} +impl VideoEncodeH264CapabilitiesEXT { + pub fn builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a> { + VideoEncodeH264CapabilitiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264CapabilitiesEXTBuilder<'a> { + inner: VideoEncodeH264CapabilitiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264CapabilitiesEXTBuilder<'a> { + type Target = VideoEncodeH264CapabilitiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264CapabilitiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH264InputModeFlagsEXT) -> Self { + self.inner.input_mode_flags = input_mode_flags; + self + } + #[inline] + pub fn output_mode_flags( + mut self, + output_mode_flags: VideoEncodeH264OutputModeFlagsEXT, + ) -> Self { + self.inner.output_mode_flags = output_mode_flags; + self + } + #[inline] + pub fn max_p_picture_l0_reference_count( + mut self, + max_p_picture_l0_reference_count: u8, + ) -> Self { + self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; + self + } + #[inline] + pub fn max_b_picture_l0_reference_count( + mut self, + max_b_picture_l0_reference_count: u8, + ) -> Self { + self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; + self + } + #[inline] + pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self { + self.inner.max_l1_reference_count = max_l1_reference_count; + self + } + #[inline] + pub fn motion_vectors_over_pic_boundaries_flag( + mut self, + motion_vectors_over_pic_boundaries_flag: bool, + ) -> Self { + self.inner.motion_vectors_over_pic_boundaries_flag = + motion_vectors_over_pic_boundaries_flag.into(); + self + } + #[inline] + pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self { + self.inner.max_bytes_per_pic_denom = max_bytes_per_pic_denom; + self + } + #[inline] + pub fn max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self { + self.inner.max_bits_per_mb_denom = max_bits_per_mb_denom; + self + } + #[inline] + pub fn log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self { + self.inner.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal; + self + } + #[inline] + pub fn log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self { + self.inner.log2_max_mv_length_vertical = log2_max_mv_length_vertical; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264CapabilitiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264SessionParametersAddInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH264PictureParameterSet, +} +impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264SessionParametersAddInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT; +} +impl VideoEncodeH264SessionParametersAddInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + VideoEncodeH264SessionParametersAddInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + inner: VideoEncodeH264SessionParametersAddInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH264SessionParametersAddInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + type Target = VideoEncodeH264SessionParametersAddInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + #[inline] + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self { + self.inner.std_sps_count = std_sp_ss.len() as _; + self.inner.p_std_sp_ss = std_sp_ss.as_ptr(); + self + } + #[inline] + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self { + self.inner.std_pps_count = std_pp_ss.len() as _; + self.inner.p_std_pp_ss = std_pp_ss.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264SessionParametersAddInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264SessionParametersCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, + pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT, +} +impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264SessionParametersCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT; +} +impl VideoEncodeH264SessionParametersCreateInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + VideoEncodeH264SessionParametersCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + inner: VideoEncodeH264SessionParametersCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH264SessionParametersCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + type Target = VideoEncodeH264SessionParametersCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + #[inline] + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.inner.max_std_sps_count = max_std_sps_count; + self + } + #[inline] + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.inner.max_std_pps_count = max_std_pps_count; + self + } + #[inline] + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264SessionParametersCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264DpbSlotInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub slot_index: i8, + pub p_std_reference_info: *const StdVideoEncodeH264ReferenceInfo, +} +impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + slot_index: i8::default(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264DpbSlotInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT; +} +impl VideoEncodeH264DpbSlotInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + VideoEncodeH264DpbSlotInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + inner: VideoEncodeH264DpbSlotInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + type Target = VideoEncodeH264DpbSlotInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + #[inline] + pub fn slot_index(mut self, slot_index: i8) -> Self { + self.inner.slot_index = slot_index; + self + } + #[inline] + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoEncodeH264ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264DpbSlotInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264VclFrameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsInfoEXT, + pub nalu_slice_entry_count: u32, + pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceInfoEXT, + pub p_current_picture_info: *const StdVideoEncodeH264PictureInfo, +} +impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_reference_final_lists: ::std::ptr::null(), + nalu_slice_entry_count: u32::default(), + p_nalu_slice_entries: ::std::ptr::null(), + p_current_picture_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264VclFrameInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT; +} +impl VideoEncodeH264VclFrameInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + VideoEncodeH264VclFrameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + inner: VideoEncodeH264VclFrameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + type Target = VideoEncodeH264VclFrameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + #[inline] + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH264ReferenceListsInfoEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + #[inline] + pub fn nalu_slice_entries( + mut self, + nalu_slice_entries: &'a [VideoEncodeH264NaluSliceInfoEXT], + ) -> Self { + self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _; + self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr(); + self + } + #[inline] + pub fn current_picture_info( + mut self, + current_picture_info: &'a StdVideoEncodeH264PictureInfo, + ) -> Self { + self.inner.p_current_picture_info = current_picture_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264VclFrameInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264ReferenceListsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub reference_list0_entry_count: u8, + pub p_reference_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT, + pub reference_list1_entry_count: u8, + pub p_reference_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT, + pub p_mem_mgmt_ctrl_operations: *const StdVideoEncodeH264RefMemMgmtCtrlOperations, +} +impl ::std::default::Default for VideoEncodeH264ReferenceListsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + reference_list0_entry_count: u8::default(), + p_reference_list0_entries: ::std::ptr::null(), + reference_list1_entry_count: u8::default(), + p_reference_list1_entries: ::std::ptr::null(), + p_mem_mgmt_ctrl_operations: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264ReferenceListsInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT; +} +impl VideoEncodeH264ReferenceListsInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + VideoEncodeH264ReferenceListsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + inner: VideoEncodeH264ReferenceListsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + type Target = VideoEncodeH264ReferenceListsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + #[inline] + pub fn reference_list0_entries( + mut self, + reference_list0_entries: &'a [VideoEncodeH264DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list0_entry_count = reference_list0_entries.len() as _; + self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr(); + self + } + #[inline] + pub fn reference_list1_entries( + mut self, + reference_list1_entries: &'a [VideoEncodeH264DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list1_entry_count = reference_list1_entries.len() as _; + self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr(); + self + } + #[inline] + pub fn mem_mgmt_ctrl_operations( + mut self, + mem_mgmt_ctrl_operations: &'a StdVideoEncodeH264RefMemMgmtCtrlOperations, + ) -> Self { + self.inner.p_mem_mgmt_ctrl_operations = mem_mgmt_ctrl_operations; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264ReferenceListsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264EmitPictureParametersInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sps_id: u8, + pub emit_sps_enable: Bool32, + pub pps_id_entry_count: u32, + pub pps_id_entries: *const u8, +} +impl ::std::default::Default for VideoEncodeH264EmitPictureParametersInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sps_id: u8::default(), + emit_sps_enable: Bool32::default(), + pps_id_entry_count: u32::default(), + pps_id_entries: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264EmitPictureParametersInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT; +} +impl VideoEncodeH264EmitPictureParametersInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + VideoEncodeH264EmitPictureParametersInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + inner: VideoEncodeH264EmitPictureParametersInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + type Target = VideoEncodeH264EmitPictureParametersInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + #[inline] + pub fn sps_id(mut self, sps_id: u8) -> Self { + self.inner.sps_id = sps_id; + self + } + #[inline] + pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { + self.inner.emit_sps_enable = emit_sps_enable.into(); + self + } + #[inline] + pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { + self.inner.pps_id_entry_count = pps_id_entries.len() as _; + self.inner.pps_id_entries = pps_id_entries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264EmitPictureParametersInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264ProfileInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH264ProfileIdc, +} +impl ::std::default::Default for VideoEncodeH264ProfileInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH264ProfileIdc::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264ProfileInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_PROFILE_INFO_EXT; +} +impl VideoEncodeH264ProfileInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264ProfileInfoEXTBuilder<'a> { + VideoEncodeH264ProfileInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264ProfileInfoEXTBuilder<'a> { + inner: VideoEncodeH264ProfileInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoEXT {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoEXTBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileInfoEXTBuilder<'a> { + type Target = VideoEncodeH264ProfileInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264ProfileInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264ProfileInfoEXTBuilder<'a> { + #[inline] + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264ProfileInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264NaluSliceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mb_count: u32, + pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsInfoEXT, + pub p_slice_header_std: *const StdVideoEncodeH264SliceHeader, +} +impl ::std::default::Default for VideoEncodeH264NaluSliceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mb_count: u32::default(), + p_reference_final_lists: ::std::ptr::null(), + p_slice_header_std: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264NaluSliceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT; +} +impl VideoEncodeH264NaluSliceInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + VideoEncodeH264NaluSliceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + inner: VideoEncodeH264NaluSliceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + type Target = VideoEncodeH264NaluSliceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + #[inline] + pub fn mb_count(mut self, mb_count: u32) -> Self { + self.inner.mb_count = mb_count; + self + } + #[inline] + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH264ReferenceListsInfoEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + #[inline] + pub fn slice_header_std(mut self, slice_header_std: &'a StdVideoEncodeH264SliceHeader) -> Self { + self.inner.p_slice_header_std = slice_header_std; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264NaluSliceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264RateControlInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub gop_frame_count: u32, + pub idr_period: u32, + pub consecutive_b_frame_count: u32, + pub rate_control_structure: VideoEncodeH264RateControlStructureEXT, + pub temporal_layer_count: u8, +} +impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + gop_frame_count: u32::default(), + idr_period: u32::default(), + consecutive_b_frame_count: u32::default(), + rate_control_structure: VideoEncodeH264RateControlStructureEXT::default(), + temporal_layer_count: u8::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264RateControlInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT; +} +impl VideoEncodeH264RateControlInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a> { + VideoEncodeH264RateControlInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264RateControlInfoEXTBuilder<'a> { + inner: VideoEncodeH264RateControlInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlInfoEXTBuilder<'a> { + type Target = VideoEncodeH264RateControlInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> { + #[inline] + pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { + self.inner.gop_frame_count = gop_frame_count; + self + } + #[inline] + pub fn idr_period(mut self, idr_period: u32) -> Self { + self.inner.idr_period = idr_period; + self + } + #[inline] + pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self { + self.inner.consecutive_b_frame_count = consecutive_b_frame_count; + self + } + #[inline] + pub fn rate_control_structure( + mut self, + rate_control_structure: VideoEncodeH264RateControlStructureEXT, + ) -> Self { + self.inner.rate_control_structure = rate_control_structure; + self + } + #[inline] + pub fn temporal_layer_count(mut self, temporal_layer_count: u8) -> Self { + self.inner.temporal_layer_count = temporal_layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264RateControlInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VideoEncodeH264QpEXT { + pub qp_i: i32, + pub qp_p: i32, + pub qp_b: i32, +} +impl VideoEncodeH264QpEXT { + pub fn builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a> { + VideoEncodeH264QpEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264QpEXTBuilder<'a> { + inner: VideoEncodeH264QpEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264QpEXTBuilder<'a> { + type Target = VideoEncodeH264QpEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264QpEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264QpEXTBuilder<'a> { + #[inline] + pub fn qp_i(mut self, qp_i: i32) -> Self { + self.inner.qp_i = qp_i; + self + } + #[inline] + pub fn qp_p(mut self, qp_p: i32) -> Self { + self.inner.qp_p = qp_p; + self + } + #[inline] + pub fn qp_b(mut self, qp_b: i32) -> Self { + self.inner.qp_b = qp_b; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264QpEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VideoEncodeH264FrameSizeEXT { + pub frame_i_size: u32, + pub frame_p_size: u32, + pub frame_b_size: u32, +} +impl VideoEncodeH264FrameSizeEXT { + pub fn builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a> { + VideoEncodeH264FrameSizeEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264FrameSizeEXTBuilder<'a> { + inner: VideoEncodeH264FrameSizeEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264FrameSizeEXTBuilder<'a> { + type Target = VideoEncodeH264FrameSizeEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264FrameSizeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264FrameSizeEXTBuilder<'a> { + #[inline] + pub fn frame_i_size(mut self, frame_i_size: u32) -> Self { + self.inner.frame_i_size = frame_i_size; + self + } + #[inline] + pub fn frame_p_size(mut self, frame_p_size: u32) -> Self { + self.inner.frame_p_size = frame_p_size; + self + } + #[inline] + pub fn frame_b_size(mut self, frame_b_size: u32) -> Self { + self.inner.frame_b_size = frame_b_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264FrameSizeEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264RateControlLayerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub temporal_layer_id: u8, + pub use_initial_rc_qp: Bool32, + pub initial_rc_qp: VideoEncodeH264QpEXT, + pub use_min_qp: Bool32, + pub min_qp: VideoEncodeH264QpEXT, + pub use_max_qp: Bool32, + pub max_qp: VideoEncodeH264QpEXT, + pub use_max_frame_size: Bool32, + pub max_frame_size: VideoEncodeH264FrameSizeEXT, +} +impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + temporal_layer_id: u8::default(), + use_initial_rc_qp: Bool32::default(), + initial_rc_qp: VideoEncodeH264QpEXT::default(), + use_min_qp: Bool32::default(), + min_qp: VideoEncodeH264QpEXT::default(), + use_max_qp: Bool32::default(), + max_qp: VideoEncodeH264QpEXT::default(), + use_max_frame_size: Bool32::default(), + max_frame_size: VideoEncodeH264FrameSizeEXT::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264RateControlLayerInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT; +} +impl VideoEncodeH264RateControlLayerInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + VideoEncodeH264RateControlLayerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + inner: VideoEncodeH264RateControlLayerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {} +unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR + for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + type Target = VideoEncodeH264RateControlLayerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + #[inline] + pub fn temporal_layer_id(mut self, temporal_layer_id: u8) -> Self { + self.inner.temporal_layer_id = temporal_layer_id; + self + } + #[inline] + pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self { + self.inner.use_initial_rc_qp = use_initial_rc_qp.into(); + self + } + #[inline] + pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self { + self.inner.initial_rc_qp = initial_rc_qp; + self + } + #[inline] + pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { + self.inner.use_min_qp = use_min_qp.into(); + self + } + #[inline] + pub fn min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self { + self.inner.min_qp = min_qp; + self + } + #[inline] + pub fn use_max_qp(mut self, use_max_qp: bool) -> Self { + self.inner.use_max_qp = use_max_qp.into(); + self + } + #[inline] + pub fn max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self { + self.inner.max_qp = max_qp; + self + } + #[inline] + pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { + self.inner.use_max_frame_size = use_max_frame_size.into(); + self + } + #[inline] + pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self { + self.inner.max_frame_size = max_frame_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264RateControlLayerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265CapabilitiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoEncodeH265CapabilityFlagsEXT, + pub input_mode_flags: VideoEncodeH265InputModeFlagsEXT, + pub output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, + pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT, + pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT, + pub max_p_picture_l0_reference_count: u8, + pub max_b_picture_l0_reference_count: u8, + pub max_l1_reference_count: u8, + pub max_sub_layers_count: u8, + pub min_log2_min_luma_coding_block_size_minus3: u8, + pub max_log2_min_luma_coding_block_size_minus3: u8, + pub min_log2_min_luma_transform_block_size_minus2: u8, + pub max_log2_min_luma_transform_block_size_minus2: u8, + pub min_max_transform_hierarchy_depth_inter: u8, + pub max_max_transform_hierarchy_depth_inter: u8, + pub min_max_transform_hierarchy_depth_intra: u8, + pub max_max_transform_hierarchy_depth_intra: u8, + pub max_diff_cu_qp_delta_depth: u8, + pub min_max_num_merge_cand: u8, + pub max_max_num_merge_cand: u8, +} +impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoEncodeH265CapabilityFlagsEXT::default(), + input_mode_flags: VideoEncodeH265InputModeFlagsEXT::default(), + output_mode_flags: VideoEncodeH265OutputModeFlagsEXT::default(), + ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(), + transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT::default(), + max_p_picture_l0_reference_count: u8::default(), + max_b_picture_l0_reference_count: u8::default(), + max_l1_reference_count: u8::default(), + max_sub_layers_count: u8::default(), + min_log2_min_luma_coding_block_size_minus3: u8::default(), + max_log2_min_luma_coding_block_size_minus3: u8::default(), + min_log2_min_luma_transform_block_size_minus2: u8::default(), + max_log2_min_luma_transform_block_size_minus2: u8::default(), + min_max_transform_hierarchy_depth_inter: u8::default(), + max_max_transform_hierarchy_depth_inter: u8::default(), + min_max_transform_hierarchy_depth_intra: u8::default(), + max_max_transform_hierarchy_depth_intra: u8::default(), + max_diff_cu_qp_delta_depth: u8::default(), + min_max_num_merge_cand: u8::default(), + max_max_num_merge_cand: u8::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265CapabilitiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_CAPABILITIES_EXT; +} +impl VideoEncodeH265CapabilitiesEXT { + pub fn builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a> { + VideoEncodeH265CapabilitiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265CapabilitiesEXTBuilder<'a> { + inner: VideoEncodeH265CapabilitiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265CapabilitiesEXTBuilder<'a> { + type Target = VideoEncodeH265CapabilitiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265CapabilitiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH265InputModeFlagsEXT) -> Self { + self.inner.input_mode_flags = input_mode_flags; + self + } + #[inline] + pub fn output_mode_flags( + mut self, + output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, + ) -> Self { + self.inner.output_mode_flags = output_mode_flags; + self + } + #[inline] + pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self { + self.inner.ctb_sizes = ctb_sizes; + self + } + #[inline] + pub fn transform_block_sizes( + mut self, + transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT, + ) -> Self { + self.inner.transform_block_sizes = transform_block_sizes; + self + } + #[inline] + pub fn max_p_picture_l0_reference_count( + mut self, + max_p_picture_l0_reference_count: u8, + ) -> Self { + self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; + self + } + #[inline] + pub fn max_b_picture_l0_reference_count( + mut self, + max_b_picture_l0_reference_count: u8, + ) -> Self { + self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; + self + } + #[inline] + pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self { + self.inner.max_l1_reference_count = max_l1_reference_count; + self + } + #[inline] + pub fn max_sub_layers_count(mut self, max_sub_layers_count: u8) -> Self { + self.inner.max_sub_layers_count = max_sub_layers_count; + self + } + #[inline] + pub fn min_log2_min_luma_coding_block_size_minus3( + mut self, + min_log2_min_luma_coding_block_size_minus3: u8, + ) -> Self { + self.inner.min_log2_min_luma_coding_block_size_minus3 = + min_log2_min_luma_coding_block_size_minus3; + self + } + #[inline] + pub fn max_log2_min_luma_coding_block_size_minus3( + mut self, + max_log2_min_luma_coding_block_size_minus3: u8, + ) -> Self { + self.inner.max_log2_min_luma_coding_block_size_minus3 = + max_log2_min_luma_coding_block_size_minus3; + self + } + #[inline] + pub fn min_log2_min_luma_transform_block_size_minus2( + mut self, + min_log2_min_luma_transform_block_size_minus2: u8, + ) -> Self { + self.inner.min_log2_min_luma_transform_block_size_minus2 = + min_log2_min_luma_transform_block_size_minus2; + self + } + #[inline] + pub fn max_log2_min_luma_transform_block_size_minus2( + mut self, + max_log2_min_luma_transform_block_size_minus2: u8, + ) -> Self { + self.inner.max_log2_min_luma_transform_block_size_minus2 = + max_log2_min_luma_transform_block_size_minus2; + self + } + #[inline] + pub fn min_max_transform_hierarchy_depth_inter( + mut self, + min_max_transform_hierarchy_depth_inter: u8, + ) -> Self { + self.inner.min_max_transform_hierarchy_depth_inter = + min_max_transform_hierarchy_depth_inter; + self + } + #[inline] + pub fn max_max_transform_hierarchy_depth_inter( + mut self, + max_max_transform_hierarchy_depth_inter: u8, + ) -> Self { + self.inner.max_max_transform_hierarchy_depth_inter = + max_max_transform_hierarchy_depth_inter; + self + } + #[inline] + pub fn min_max_transform_hierarchy_depth_intra( + mut self, + min_max_transform_hierarchy_depth_intra: u8, + ) -> Self { + self.inner.min_max_transform_hierarchy_depth_intra = + min_max_transform_hierarchy_depth_intra; + self + } + #[inline] + pub fn max_max_transform_hierarchy_depth_intra( + mut self, + max_max_transform_hierarchy_depth_intra: u8, + ) -> Self { + self.inner.max_max_transform_hierarchy_depth_intra = + max_max_transform_hierarchy_depth_intra; + self + } + #[inline] + pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u8) -> Self { + self.inner.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth; + self + } + #[inline] + pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u8) -> Self { + self.inner.min_max_num_merge_cand = min_max_num_merge_cand; + self + } + #[inline] + pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u8) -> Self { + self.inner.max_max_num_merge_cand = max_max_num_merge_cand; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265CapabilitiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265SessionParametersAddInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_vps_count: u32, + pub p_std_vp_ss: *const StdVideoH265VideoParameterSet, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH265PictureParameterSet, +} +impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_vps_count: u32::default(), + p_std_vp_ss: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265SessionParametersAddInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT; +} +impl VideoEncodeH265SessionParametersAddInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + VideoEncodeH265SessionParametersAddInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + inner: VideoEncodeH265SessionParametersAddInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH265SessionParametersAddInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + type Target = VideoEncodeH265SessionParametersAddInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + #[inline] + pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self { + self.inner.std_vps_count = std_vp_ss.len() as _; + self.inner.p_std_vp_ss = std_vp_ss.as_ptr(); + self + } + #[inline] + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self { + self.inner.std_sps_count = std_sp_ss.len() as _; + self.inner.p_std_sp_ss = std_sp_ss.as_ptr(); + self + } + #[inline] + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self { + self.inner.std_pps_count = std_pp_ss.len() as _; + self.inner.p_std_pp_ss = std_pp_ss.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265SessionParametersAddInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265SessionParametersCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_std_vps_count: u32, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, + pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT, +} +impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_std_vps_count: u32::default(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265SessionParametersCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT; +} +impl VideoEncodeH265SessionParametersCreateInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + VideoEncodeH265SessionParametersCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + inner: VideoEncodeH265SessionParametersCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH265SessionParametersCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + type Target = VideoEncodeH265SessionParametersCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + #[inline] + pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { + self.inner.max_std_vps_count = max_std_vps_count; + self + } + #[inline] + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.inner.max_std_sps_count = max_std_sps_count; + self + } + #[inline] + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.inner.max_std_pps_count = max_std_pps_count; + self + } + #[inline] + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265SessionParametersCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265VclFrameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsInfoEXT, + pub nalu_slice_segment_entry_count: u32, + pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoEXT, + pub p_current_picture_info: *const StdVideoEncodeH265PictureInfo, +} +impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_reference_final_lists: ::std::ptr::null(), + nalu_slice_segment_entry_count: u32::default(), + p_nalu_slice_segment_entries: ::std::ptr::null(), + p_current_picture_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265VclFrameInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT; +} +impl VideoEncodeH265VclFrameInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + VideoEncodeH265VclFrameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + inner: VideoEncodeH265VclFrameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + type Target = VideoEncodeH265VclFrameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + #[inline] + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH265ReferenceListsInfoEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + #[inline] + pub fn nalu_slice_segment_entries( + mut self, + nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentInfoEXT], + ) -> Self { + self.inner.nalu_slice_segment_entry_count = nalu_slice_segment_entries.len() as _; + self.inner.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr(); + self + } + #[inline] + pub fn current_picture_info( + mut self, + current_picture_info: &'a StdVideoEncodeH265PictureInfo, + ) -> Self { + self.inner.p_current_picture_info = current_picture_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265VclFrameInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265EmitPictureParametersInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vps_id: u8, + pub sps_id: u8, + pub emit_vps_enable: Bool32, + pub emit_sps_enable: Bool32, + pub pps_id_entry_count: u32, + pub pps_id_entries: *const u8, +} +impl ::std::default::Default for VideoEncodeH265EmitPictureParametersInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vps_id: u8::default(), + sps_id: u8::default(), + emit_vps_enable: Bool32::default(), + emit_sps_enable: Bool32::default(), + pps_id_entry_count: u32::default(), + pps_id_entries: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265EmitPictureParametersInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT; +} +impl VideoEncodeH265EmitPictureParametersInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + VideoEncodeH265EmitPictureParametersInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + inner: VideoEncodeH265EmitPictureParametersInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + type Target = VideoEncodeH265EmitPictureParametersInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + #[inline] + pub fn vps_id(mut self, vps_id: u8) -> Self { + self.inner.vps_id = vps_id; + self + } + #[inline] + pub fn sps_id(mut self, sps_id: u8) -> Self { + self.inner.sps_id = sps_id; + self + } + #[inline] + pub fn emit_vps_enable(mut self, emit_vps_enable: bool) -> Self { + self.inner.emit_vps_enable = emit_vps_enable.into(); + self + } + #[inline] + pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { + self.inner.emit_sps_enable = emit_sps_enable.into(); + self + } + #[inline] + pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { + self.inner.pps_id_entry_count = pps_id_entries.len() as _; + self.inner.pps_id_entries = pps_id_entries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265EmitPictureParametersInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265NaluSliceSegmentInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ctb_count: u32, + pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsInfoEXT, + pub p_slice_segment_header_std: *const StdVideoEncodeH265SliceSegmentHeader, +} +impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ctb_count: u32::default(), + p_reference_final_lists: ::std::ptr::null(), + p_slice_segment_header_std: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265NaluSliceSegmentInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT; +} +impl VideoEncodeH265NaluSliceSegmentInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + VideoEncodeH265NaluSliceSegmentInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + inner: VideoEncodeH265NaluSliceSegmentInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + type Target = VideoEncodeH265NaluSliceSegmentInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + #[inline] + pub fn ctb_count(mut self, ctb_count: u32) -> Self { + self.inner.ctb_count = ctb_count; + self + } + #[inline] + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH265ReferenceListsInfoEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + #[inline] + pub fn slice_segment_header_std( + mut self, + slice_segment_header_std: &'a StdVideoEncodeH265SliceSegmentHeader, + ) -> Self { + self.inner.p_slice_segment_header_std = slice_segment_header_std; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265NaluSliceSegmentInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265RateControlInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub gop_frame_count: u32, + pub idr_period: u32, + pub consecutive_b_frame_count: u32, + pub rate_control_structure: VideoEncodeH265RateControlStructureEXT, + pub sub_layer_count: u8, +} +impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + gop_frame_count: u32::default(), + idr_period: u32::default(), + consecutive_b_frame_count: u32::default(), + rate_control_structure: VideoEncodeH265RateControlStructureEXT::default(), + sub_layer_count: u8::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265RateControlInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT; +} +impl VideoEncodeH265RateControlInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a> { + VideoEncodeH265RateControlInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265RateControlInfoEXTBuilder<'a> { + inner: VideoEncodeH265RateControlInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlInfoEXTBuilder<'a> { + type Target = VideoEncodeH265RateControlInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> { + #[inline] + pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { + self.inner.gop_frame_count = gop_frame_count; + self + } + #[inline] + pub fn idr_period(mut self, idr_period: u32) -> Self { + self.inner.idr_period = idr_period; + self + } + #[inline] + pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self { + self.inner.consecutive_b_frame_count = consecutive_b_frame_count; + self + } + #[inline] + pub fn rate_control_structure( + mut self, + rate_control_structure: VideoEncodeH265RateControlStructureEXT, + ) -> Self { + self.inner.rate_control_structure = rate_control_structure; + self + } + #[inline] + pub fn sub_layer_count(mut self, sub_layer_count: u8) -> Self { + self.inner.sub_layer_count = sub_layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265RateControlInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VideoEncodeH265QpEXT { + pub qp_i: i32, + pub qp_p: i32, + pub qp_b: i32, +} +impl VideoEncodeH265QpEXT { + pub fn builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a> { + VideoEncodeH265QpEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265QpEXTBuilder<'a> { + inner: VideoEncodeH265QpEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265QpEXTBuilder<'a> { + type Target = VideoEncodeH265QpEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265QpEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265QpEXTBuilder<'a> { + #[inline] + pub fn qp_i(mut self, qp_i: i32) -> Self { + self.inner.qp_i = qp_i; + self + } + #[inline] + pub fn qp_p(mut self, qp_p: i32) -> Self { + self.inner.qp_p = qp_p; + self + } + #[inline] + pub fn qp_b(mut self, qp_b: i32) -> Self { + self.inner.qp_b = qp_b; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265QpEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VideoEncodeH265FrameSizeEXT { + pub frame_i_size: u32, + pub frame_p_size: u32, + pub frame_b_size: u32, +} +impl VideoEncodeH265FrameSizeEXT { + pub fn builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a> { + VideoEncodeH265FrameSizeEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265FrameSizeEXTBuilder<'a> { + inner: VideoEncodeH265FrameSizeEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265FrameSizeEXTBuilder<'a> { + type Target = VideoEncodeH265FrameSizeEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265FrameSizeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265FrameSizeEXTBuilder<'a> { + #[inline] + pub fn frame_i_size(mut self, frame_i_size: u32) -> Self { + self.inner.frame_i_size = frame_i_size; + self + } + #[inline] + pub fn frame_p_size(mut self, frame_p_size: u32) -> Self { + self.inner.frame_p_size = frame_p_size; + self + } + #[inline] + pub fn frame_b_size(mut self, frame_b_size: u32) -> Self { + self.inner.frame_b_size = frame_b_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265FrameSizeEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265RateControlLayerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub temporal_id: u8, + pub use_initial_rc_qp: Bool32, + pub initial_rc_qp: VideoEncodeH265QpEXT, + pub use_min_qp: Bool32, + pub min_qp: VideoEncodeH265QpEXT, + pub use_max_qp: Bool32, + pub max_qp: VideoEncodeH265QpEXT, + pub use_max_frame_size: Bool32, + pub max_frame_size: VideoEncodeH265FrameSizeEXT, +} +impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + temporal_id: u8::default(), + use_initial_rc_qp: Bool32::default(), + initial_rc_qp: VideoEncodeH265QpEXT::default(), + use_min_qp: Bool32::default(), + min_qp: VideoEncodeH265QpEXT::default(), + use_max_qp: Bool32::default(), + max_qp: VideoEncodeH265QpEXT::default(), + use_max_frame_size: Bool32::default(), + max_frame_size: VideoEncodeH265FrameSizeEXT::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265RateControlLayerInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT; +} +impl VideoEncodeH265RateControlLayerInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + VideoEncodeH265RateControlLayerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + inner: VideoEncodeH265RateControlLayerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {} +unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR + for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + type Target = VideoEncodeH265RateControlLayerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + #[inline] + pub fn temporal_id(mut self, temporal_id: u8) -> Self { + self.inner.temporal_id = temporal_id; + self + } + #[inline] + pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self { + self.inner.use_initial_rc_qp = use_initial_rc_qp.into(); + self + } + #[inline] + pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self { + self.inner.initial_rc_qp = initial_rc_qp; + self + } + #[inline] + pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { + self.inner.use_min_qp = use_min_qp.into(); + self + } + #[inline] + pub fn min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self { + self.inner.min_qp = min_qp; + self + } + #[inline] + pub fn use_max_qp(mut self, use_max_qp: bool) -> Self { + self.inner.use_max_qp = use_max_qp.into(); + self + } + #[inline] + pub fn max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self { + self.inner.max_qp = max_qp; + self + } + #[inline] + pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { + self.inner.use_max_frame_size = use_max_frame_size.into(); + self + } + #[inline] + pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self { + self.inner.max_frame_size = max_frame_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265RateControlLayerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265ProfileInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH265ProfileIdc, +} +impl ::std::default::Default for VideoEncodeH265ProfileInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH265ProfileIdc::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265ProfileInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_PROFILE_INFO_EXT; +} +impl VideoEncodeH265ProfileInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265ProfileInfoEXTBuilder<'a> { + VideoEncodeH265ProfileInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265ProfileInfoEXTBuilder<'a> { + inner: VideoEncodeH265ProfileInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoEXT {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoEXTBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileInfoEXTBuilder<'a> { + type Target = VideoEncodeH265ProfileInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265ProfileInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265ProfileInfoEXTBuilder<'a> { + #[inline] + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265ProfileInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265DpbSlotInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub slot_index: i8, + pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo, +} +impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + slot_index: i8::default(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265DpbSlotInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT; +} +impl VideoEncodeH265DpbSlotInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + VideoEncodeH265DpbSlotInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + inner: VideoEncodeH265DpbSlotInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + type Target = VideoEncodeH265DpbSlotInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + #[inline] + pub fn slot_index(mut self, slot_index: i8) -> Self { + self.inner.slot_index = slot_index; + self + } + #[inline] + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoEncodeH265ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265DpbSlotInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265ReferenceListsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub reference_list0_entry_count: u8, + pub p_reference_list0_entries: *const VideoEncodeH265DpbSlotInfoEXT, + pub reference_list1_entry_count: u8, + pub p_reference_list1_entries: *const VideoEncodeH265DpbSlotInfoEXT, + pub p_reference_modifications: *const StdVideoEncodeH265ReferenceModifications, +} +impl ::std::default::Default for VideoEncodeH265ReferenceListsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + reference_list0_entry_count: u8::default(), + p_reference_list0_entries: ::std::ptr::null(), + reference_list1_entry_count: u8::default(), + p_reference_list1_entries: ::std::ptr::null(), + p_reference_modifications: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265ReferenceListsInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT; +} +impl VideoEncodeH265ReferenceListsInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + VideoEncodeH265ReferenceListsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + inner: VideoEncodeH265ReferenceListsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + type Target = VideoEncodeH265ReferenceListsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + #[inline] + pub fn reference_list0_entries( + mut self, + reference_list0_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list0_entry_count = reference_list0_entries.len() as _; + self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr(); + self + } + #[inline] + pub fn reference_list1_entries( + mut self, + reference_list1_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list1_entry_count = reference_list1_entries.len() as _; + self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr(); + self + } + #[inline] + pub fn reference_modifications( + mut self, + reference_modifications: &'a StdVideoEncodeH265ReferenceModifications, + ) -> Self { + self.inner.p_reference_modifications = reference_modifications; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265ReferenceListsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub inherited_viewport_scissor2_d: Bool32, +} +impl ::std::default::Default for PhysicalDeviceInheritedViewportScissorFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + inherited_viewport_scissor2_d: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceInheritedViewportScissorFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; +} +impl PhysicalDeviceInheritedViewportScissorFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + inner: PhysicalDeviceInheritedViewportScissorFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInheritedViewportScissorFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceInheritedViewportScissorFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + #[inline] + pub fn inherited_viewport_scissor2_d(mut self, inherited_viewport_scissor2_d: bool) -> Self { + self.inner.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceInheritedViewportScissorFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceViewportScissorInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub viewport_scissor2_d: Bool32, + pub viewport_depth_count: u32, + pub p_viewport_depths: *const Viewport, +} +impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + viewport_scissor2_d: Bool32::default(), + viewport_depth_count: u32::default(), + p_viewport_depths: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceViewportScissorInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; +} +impl CommandBufferInheritanceViewportScissorInfoNV { + pub fn builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + CommandBufferInheritanceViewportScissorInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + inner: CommandBufferInheritanceViewportScissorInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceViewportScissorInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceViewportScissorInfoNV {} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + type Target = CommandBufferInheritanceViewportScissorInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + #[inline] + pub fn viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self { + self.inner.viewport_scissor2_d = viewport_scissor2_d.into(); + self + } + #[inline] + pub fn viewport_depth_count(mut self, viewport_depth_count: u32) -> Self { + self.inner.viewport_depth_count = viewport_depth_count; + self + } + #[inline] + pub fn viewport_depths(mut self, viewport_depths: &'a Viewport) -> Self { + self.inner.p_viewport_depths = viewport_depths; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceViewportScissorInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ycbcr2plane444_formats: Bool32, +} +impl ::std::default::Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ycbcr2plane444_formats: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; +} +impl PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + #[inline] + pub fn ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self { + self.inner.ycbcr2plane444_formats = ycbcr2plane444_formats.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProvokingVertexFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub provoking_vertex_last: Bool32, + pub transform_feedback_preserves_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + provoking_vertex_last: Bool32::default(), + transform_feedback_preserves_provoking_vertex: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProvokingVertexFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; +} +impl PhysicalDeviceProvokingVertexFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + PhysicalDeviceProvokingVertexFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceProvokingVertexFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceProvokingVertexFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + #[inline] + pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self { + self.inner.provoking_vertex_last = provoking_vertex_last.into(); + self + } + #[inline] + pub fn transform_feedback_preserves_provoking_vertex( + mut self, + transform_feedback_preserves_provoking_vertex: bool, + ) -> Self { + self.inner.transform_feedback_preserves_provoking_vertex = + transform_feedback_preserves_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProvokingVertexFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProvokingVertexPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub provoking_vertex_mode_per_pipeline: Bool32, + pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + provoking_vertex_mode_per_pipeline: Bool32::default(), + transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProvokingVertexPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; +} +impl PhysicalDeviceProvokingVertexPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + PhysicalDeviceProvokingVertexPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceProvokingVertexPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceProvokingVertexPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + #[inline] + pub fn provoking_vertex_mode_per_pipeline( + mut self, + provoking_vertex_mode_per_pipeline: bool, + ) -> Self { + self.inner.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into(); + self + } + #[inline] + pub fn transform_feedback_preserves_triangle_fan_provoking_vertex( + mut self, + transform_feedback_preserves_triangle_fan_provoking_vertex: bool, + ) -> Self { + self.inner + .transform_feedback_preserves_triangle_fan_provoking_vertex = + transform_feedback_preserves_triangle_fan_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProvokingVertexPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub provoking_vertex_mode: ProvokingVertexModeEXT, +} +impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + provoking_vertex_mode: ProvokingVertexModeEXT::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationProvokingVertexStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; +} +impl PipelineRasterizationProvokingVertexStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationProvokingVertexStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationProvokingVertexStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self { + self.inner.provoking_vertex_mode = provoking_vertex_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationProvokingVertexStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CuModuleCreateInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub data_size: usize, + pub p_data: *const c_void, +} +impl ::std::default::Default for CuModuleCreateInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + data_size: usize::default(), + p_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CuModuleCreateInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::CU_MODULE_CREATE_INFO_NVX; +} +impl CuModuleCreateInfoNVX { + pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> { + CuModuleCreateInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuModuleCreateInfoNVXBuilder<'a> { + inner: CuModuleCreateInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuModuleCreateInfoNVXBuilder<'a> { + type Target = CuModuleCreateInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuModuleCreateInfoNVXBuilder<'a> { + #[inline] + pub fn data(mut self, data: &'a [u8]) -> Self { + self.inner.data_size = data.len(); + self.inner.p_data = data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuModuleCreateInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CuFunctionCreateInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub module: CuModuleNVX, + pub p_name: *const c_char, +} +impl ::std::default::Default for CuFunctionCreateInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + module: CuModuleNVX::default(), + p_name: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CuFunctionCreateInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::CU_FUNCTION_CREATE_INFO_NVX; +} +impl CuFunctionCreateInfoNVX { + pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> { + CuFunctionCreateInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuFunctionCreateInfoNVXBuilder<'a> { + inner: CuFunctionCreateInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuFunctionCreateInfoNVXBuilder<'a> { + type Target = CuFunctionCreateInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuFunctionCreateInfoNVXBuilder<'a> { + #[inline] + pub fn module(mut self, module: CuModuleNVX) -> Self { + self.inner.module = module; + self + } + #[inline] + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_name = name.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuFunctionCreateInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CuLaunchInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub function: CuFunctionNVX, + pub grid_dim_x: u32, + pub grid_dim_y: u32, + pub grid_dim_z: u32, + pub block_dim_x: u32, + pub block_dim_y: u32, + pub block_dim_z: u32, + pub shared_mem_bytes: u32, + pub param_count: usize, + pub p_params: *const *const c_void, + pub extra_count: usize, + pub p_extras: *const *const c_void, +} +impl ::std::default::Default for CuLaunchInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + function: CuFunctionNVX::default(), + grid_dim_x: u32::default(), + grid_dim_y: u32::default(), + grid_dim_z: u32::default(), + block_dim_x: u32::default(), + block_dim_y: u32::default(), + block_dim_z: u32::default(), + shared_mem_bytes: u32::default(), + param_count: usize::default(), + p_params: ::std::ptr::null(), + extra_count: usize::default(), + p_extras: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CuLaunchInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::CU_LAUNCH_INFO_NVX; +} +impl CuLaunchInfoNVX { + pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> { + CuLaunchInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuLaunchInfoNVXBuilder<'a> { + inner: CuLaunchInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuLaunchInfoNVXBuilder<'a> { + type Target = CuLaunchInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuLaunchInfoNVXBuilder<'a> { + #[inline] + pub fn function(mut self, function: CuFunctionNVX) -> Self { + self.inner.function = function; + self + } + #[inline] + pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self { + self.inner.grid_dim_x = grid_dim_x; + self + } + #[inline] + pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self { + self.inner.grid_dim_y = grid_dim_y; + self + } + #[inline] + pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self { + self.inner.grid_dim_z = grid_dim_z; + self + } + #[inline] + pub fn block_dim_x(mut self, block_dim_x: u32) -> Self { + self.inner.block_dim_x = block_dim_x; + self + } + #[inline] + pub fn block_dim_y(mut self, block_dim_y: u32) -> Self { + self.inner.block_dim_y = block_dim_y; + self + } + #[inline] + pub fn block_dim_z(mut self, block_dim_z: u32) -> Self { + self.inner.block_dim_z = block_dim_z; + self + } + #[inline] + pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self { + self.inner.shared_mem_bytes = shared_mem_bytes; + self + } + #[inline] + pub fn params(mut self, params: &'a [*const c_void]) -> Self { + self.inner.param_count = params.len(); + self.inner.p_params = params.as_ptr(); + self + } + #[inline] + pub fn extras(mut self, extras: &'a [*const c_void]) -> Self { + self.inner.extra_count = extras.len(); + self.inner.p_extras = extras.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuLaunchInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_buffer: Bool32, + pub descriptor_buffer_capture_replay: Bool32, + pub descriptor_buffer_image_layout_ignored: Bool32, + pub descriptor_buffer_push_descriptors: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_buffer: Bool32::default(), + descriptor_buffer_capture_replay: Bool32::default(), + descriptor_buffer_image_layout_ignored: Bool32::default(), + descriptor_buffer_push_descriptors: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; +} +impl PhysicalDeviceDescriptorBufferFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + PhysicalDeviceDescriptorBufferFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDescriptorBufferFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDescriptorBufferFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + #[inline] + pub fn descriptor_buffer(mut self, descriptor_buffer: bool) -> Self { + self.inner.descriptor_buffer = descriptor_buffer.into(); + self + } + #[inline] + pub fn descriptor_buffer_capture_replay( + mut self, + descriptor_buffer_capture_replay: bool, + ) -> Self { + self.inner.descriptor_buffer_capture_replay = descriptor_buffer_capture_replay.into(); + self + } + #[inline] + pub fn descriptor_buffer_image_layout_ignored( + mut self, + descriptor_buffer_image_layout_ignored: bool, + ) -> Self { + self.inner.descriptor_buffer_image_layout_ignored = + descriptor_buffer_image_layout_ignored.into(); + self + } + #[inline] + pub fn descriptor_buffer_push_descriptors( + mut self, + descriptor_buffer_push_descriptors: bool, + ) -> Self { + self.inner.descriptor_buffer_push_descriptors = descriptor_buffer_push_descriptors.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorBufferFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_descriptor_single_array: Bool32, + pub bufferless_push_descriptors: Bool32, + pub allow_sampler_image_view_post_submit_creation: Bool32, + pub descriptor_buffer_offset_alignment: DeviceSize, + pub max_descriptor_buffer_bindings: u32, + pub max_resource_descriptor_buffer_bindings: u32, + pub max_sampler_descriptor_buffer_bindings: u32, + pub max_embedded_immutable_sampler_bindings: u32, + pub max_embedded_immutable_samplers: u32, + pub buffer_capture_replay_descriptor_data_size: usize, + pub image_capture_replay_descriptor_data_size: usize, + pub image_view_capture_replay_descriptor_data_size: usize, + pub sampler_capture_replay_descriptor_data_size: usize, + pub acceleration_structure_capture_replay_descriptor_data_size: usize, + pub sampler_descriptor_size: usize, + pub combined_image_sampler_descriptor_size: usize, + pub sampled_image_descriptor_size: usize, + pub storage_image_descriptor_size: usize, + pub uniform_texel_buffer_descriptor_size: usize, + pub robust_uniform_texel_buffer_descriptor_size: usize, + pub storage_texel_buffer_descriptor_size: usize, + pub robust_storage_texel_buffer_descriptor_size: usize, + pub uniform_buffer_descriptor_size: usize, + pub robust_uniform_buffer_descriptor_size: usize, + pub storage_buffer_descriptor_size: usize, + pub robust_storage_buffer_descriptor_size: usize, + pub input_attachment_descriptor_size: usize, + pub acceleration_structure_descriptor_size: usize, + pub max_sampler_descriptor_buffer_range: DeviceSize, + pub max_resource_descriptor_buffer_range: DeviceSize, + pub sampler_descriptor_buffer_address_space_size: DeviceSize, + pub resource_descriptor_buffer_address_space_size: DeviceSize, + pub descriptor_buffer_address_space_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_descriptor_single_array: Bool32::default(), + bufferless_push_descriptors: Bool32::default(), + allow_sampler_image_view_post_submit_creation: Bool32::default(), + descriptor_buffer_offset_alignment: DeviceSize::default(), + max_descriptor_buffer_bindings: u32::default(), + max_resource_descriptor_buffer_bindings: u32::default(), + max_sampler_descriptor_buffer_bindings: u32::default(), + max_embedded_immutable_sampler_bindings: u32::default(), + max_embedded_immutable_samplers: u32::default(), + buffer_capture_replay_descriptor_data_size: usize::default(), + image_capture_replay_descriptor_data_size: usize::default(), + image_view_capture_replay_descriptor_data_size: usize::default(), + sampler_capture_replay_descriptor_data_size: usize::default(), + acceleration_structure_capture_replay_descriptor_data_size: usize::default(), + sampler_descriptor_size: usize::default(), + combined_image_sampler_descriptor_size: usize::default(), + sampled_image_descriptor_size: usize::default(), + storage_image_descriptor_size: usize::default(), + uniform_texel_buffer_descriptor_size: usize::default(), + robust_uniform_texel_buffer_descriptor_size: usize::default(), + storage_texel_buffer_descriptor_size: usize::default(), + robust_storage_texel_buffer_descriptor_size: usize::default(), + uniform_buffer_descriptor_size: usize::default(), + robust_uniform_buffer_descriptor_size: usize::default(), + storage_buffer_descriptor_size: usize::default(), + robust_storage_buffer_descriptor_size: usize::default(), + input_attachment_descriptor_size: usize::default(), + acceleration_structure_descriptor_size: usize::default(), + max_sampler_descriptor_buffer_range: DeviceSize::default(), + max_resource_descriptor_buffer_range: DeviceSize::default(), + sampler_descriptor_buffer_address_space_size: DeviceSize::default(), + resource_descriptor_buffer_address_space_size: DeviceSize::default(), + descriptor_buffer_address_space_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; +} +impl PhysicalDeviceDescriptorBufferPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + PhysicalDeviceDescriptorBufferPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDescriptorBufferPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDescriptorBufferPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + #[inline] + pub fn combined_image_sampler_descriptor_single_array( + mut self, + combined_image_sampler_descriptor_single_array: bool, + ) -> Self { + self.inner.combined_image_sampler_descriptor_single_array = + combined_image_sampler_descriptor_single_array.into(); + self + } + #[inline] + pub fn bufferless_push_descriptors(mut self, bufferless_push_descriptors: bool) -> Self { + self.inner.bufferless_push_descriptors = bufferless_push_descriptors.into(); + self + } + #[inline] + pub fn allow_sampler_image_view_post_submit_creation( + mut self, + allow_sampler_image_view_post_submit_creation: bool, + ) -> Self { + self.inner.allow_sampler_image_view_post_submit_creation = + allow_sampler_image_view_post_submit_creation.into(); + self + } + #[inline] + pub fn descriptor_buffer_offset_alignment( + mut self, + descriptor_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.descriptor_buffer_offset_alignment = descriptor_buffer_offset_alignment; + self + } + #[inline] + pub fn max_descriptor_buffer_bindings(mut self, max_descriptor_buffer_bindings: u32) -> Self { + self.inner.max_descriptor_buffer_bindings = max_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_resource_descriptor_buffer_bindings( + mut self, + max_resource_descriptor_buffer_bindings: u32, + ) -> Self { + self.inner.max_resource_descriptor_buffer_bindings = + max_resource_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_sampler_descriptor_buffer_bindings( + mut self, + max_sampler_descriptor_buffer_bindings: u32, + ) -> Self { + self.inner.max_sampler_descriptor_buffer_bindings = max_sampler_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_embedded_immutable_sampler_bindings( + mut self, + max_embedded_immutable_sampler_bindings: u32, + ) -> Self { + self.inner.max_embedded_immutable_sampler_bindings = + max_embedded_immutable_sampler_bindings; + self + } + #[inline] + pub fn max_embedded_immutable_samplers(mut self, max_embedded_immutable_samplers: u32) -> Self { + self.inner.max_embedded_immutable_samplers = max_embedded_immutable_samplers; + self + } + #[inline] + pub fn buffer_capture_replay_descriptor_data_size( + mut self, + buffer_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner.buffer_capture_replay_descriptor_data_size = + buffer_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn image_capture_replay_descriptor_data_size( + mut self, + image_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner.image_capture_replay_descriptor_data_size = + image_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn image_view_capture_replay_descriptor_data_size( + mut self, + image_view_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner.image_view_capture_replay_descriptor_data_size = + image_view_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn sampler_capture_replay_descriptor_data_size( + mut self, + sampler_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner.sampler_capture_replay_descriptor_data_size = + sampler_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn acceleration_structure_capture_replay_descriptor_data_size( + mut self, + acceleration_structure_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner + .acceleration_structure_capture_replay_descriptor_data_size = + acceleration_structure_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn sampler_descriptor_size(mut self, sampler_descriptor_size: usize) -> Self { + self.inner.sampler_descriptor_size = sampler_descriptor_size; + self + } + #[inline] + pub fn combined_image_sampler_descriptor_size( + mut self, + combined_image_sampler_descriptor_size: usize, + ) -> Self { + self.inner.combined_image_sampler_descriptor_size = combined_image_sampler_descriptor_size; + self + } + #[inline] + pub fn sampled_image_descriptor_size(mut self, sampled_image_descriptor_size: usize) -> Self { + self.inner.sampled_image_descriptor_size = sampled_image_descriptor_size; + self + } + #[inline] + pub fn storage_image_descriptor_size(mut self, storage_image_descriptor_size: usize) -> Self { + self.inner.storage_image_descriptor_size = storage_image_descriptor_size; + self + } + #[inline] + pub fn uniform_texel_buffer_descriptor_size( + mut self, + uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.inner.uniform_texel_buffer_descriptor_size = uniform_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_uniform_texel_buffer_descriptor_size( + mut self, + robust_uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.inner.robust_uniform_texel_buffer_descriptor_size = + robust_uniform_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn storage_texel_buffer_descriptor_size( + mut self, + storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.inner.storage_texel_buffer_descriptor_size = storage_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_storage_texel_buffer_descriptor_size( + mut self, + robust_storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.inner.robust_storage_texel_buffer_descriptor_size = + robust_storage_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn uniform_buffer_descriptor_size(mut self, uniform_buffer_descriptor_size: usize) -> Self { + self.inner.uniform_buffer_descriptor_size = uniform_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_uniform_buffer_descriptor_size( + mut self, + robust_uniform_buffer_descriptor_size: usize, + ) -> Self { + self.inner.robust_uniform_buffer_descriptor_size = robust_uniform_buffer_descriptor_size; + self + } + #[inline] + pub fn storage_buffer_descriptor_size(mut self, storage_buffer_descriptor_size: usize) -> Self { + self.inner.storage_buffer_descriptor_size = storage_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_storage_buffer_descriptor_size( + mut self, + robust_storage_buffer_descriptor_size: usize, + ) -> Self { + self.inner.robust_storage_buffer_descriptor_size = robust_storage_buffer_descriptor_size; + self + } + #[inline] + pub fn input_attachment_descriptor_size( + mut self, + input_attachment_descriptor_size: usize, + ) -> Self { + self.inner.input_attachment_descriptor_size = input_attachment_descriptor_size; + self + } + #[inline] + pub fn acceleration_structure_descriptor_size( + mut self, + acceleration_structure_descriptor_size: usize, + ) -> Self { + self.inner.acceleration_structure_descriptor_size = acceleration_structure_descriptor_size; + self + } + #[inline] + pub fn max_sampler_descriptor_buffer_range( + mut self, + max_sampler_descriptor_buffer_range: DeviceSize, + ) -> Self { + self.inner.max_sampler_descriptor_buffer_range = max_sampler_descriptor_buffer_range; + self + } + #[inline] + pub fn max_resource_descriptor_buffer_range( + mut self, + max_resource_descriptor_buffer_range: DeviceSize, + ) -> Self { + self.inner.max_resource_descriptor_buffer_range = max_resource_descriptor_buffer_range; + self + } + #[inline] + pub fn sampler_descriptor_buffer_address_space_size( + mut self, + sampler_descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.inner.sampler_descriptor_buffer_address_space_size = + sampler_descriptor_buffer_address_space_size; + self + } + #[inline] + pub fn resource_descriptor_buffer_address_space_size( + mut self, + resource_descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.inner.resource_descriptor_buffer_address_space_size = + resource_descriptor_buffer_address_space_size; + self + } + #[inline] + pub fn descriptor_buffer_address_space_size( + mut self, + descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.inner.descriptor_buffer_address_space_size = descriptor_buffer_address_space_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorBufferPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_density_map_descriptor_size: usize, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_density_map_descriptor_size: usize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; +} +impl PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + #[inline] + pub fn combined_image_sampler_density_map_descriptor_size( + mut self, + combined_image_sampler_density_map_descriptor_size: usize, + ) -> Self { + self.inner + .combined_image_sampler_density_map_descriptor_size = + combined_image_sampler_density_map_descriptor_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorAddressInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address: DeviceAddress, + pub range: DeviceSize, + pub format: Format, +} +impl ::std::default::Default for DescriptorAddressInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address: DeviceAddress::default(), + range: DeviceSize::default(), + format: Format::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorAddressInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_ADDRESS_INFO_EXT; +} +impl DescriptorAddressInfoEXT { + pub fn builder<'a>() -> DescriptorAddressInfoEXTBuilder<'a> { + DescriptorAddressInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorAddressInfoEXTBuilder<'a> { + inner: DescriptorAddressInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorAddressInfoEXTBuilder<'a> { + type Target = DescriptorAddressInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorAddressInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorAddressInfoEXTBuilder<'a> { + #[inline] + pub fn address(mut self, address: DeviceAddress) -> Self { + self.inner.address = address; + self + } + #[inline] + pub fn range(mut self, range: DeviceSize) -> Self { + self.inner.range = range; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorAddressInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorBufferBindingInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address: DeviceAddress, + pub usage: BufferUsageFlags, +} +impl ::std::default::Default for DescriptorBufferBindingInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address: DeviceAddress::default(), + usage: BufferUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorBufferBindingInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT; +} +impl DescriptorBufferBindingInfoEXT { + pub fn builder<'a>() -> DescriptorBufferBindingInfoEXTBuilder<'a> { + DescriptorBufferBindingInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorBufferBindingInfoEXTBuilder<'a> { + inner: DescriptorBufferBindingInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorBufferBindingInfoEXT {} +impl<'a> ::std::ops::Deref for DescriptorBufferBindingInfoEXTBuilder<'a> { + type Target = DescriptorBufferBindingInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorBufferBindingInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorBufferBindingInfoEXTBuilder<'a> { + #[inline] + pub fn address(mut self, address: DeviceAddress) -> Self { + self.inner.address = address; + self + } + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorBufferBindingInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorBufferBindingPushDescriptorBufferHandleEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; +} +impl DescriptorBufferBindingPushDescriptorBufferHandleEXT { + pub fn builder<'a>() -> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + inner: DescriptorBufferBindingPushDescriptorBufferHandleEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorBufferBindingInfoEXT + for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorBufferBindingInfoEXT + for DescriptorBufferBindingPushDescriptorBufferHandleEXT +{ +} +impl<'a> ::std::ops::Deref for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + type Target = DescriptorBufferBindingPushDescriptorBufferHandleEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorBufferBindingPushDescriptorBufferHandleEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union DescriptorDataEXT { + pub p_sampler: *const Sampler, + pub p_combined_image_sampler: *const DescriptorImageInfo, + pub p_input_attachment_image: *const DescriptorImageInfo, + pub p_sampled_image: *const DescriptorImageInfo, + pub p_storage_image: *const DescriptorImageInfo, + pub p_uniform_texel_buffer: *const DescriptorAddressInfoEXT, + pub p_storage_texel_buffer: *const DescriptorAddressInfoEXT, + pub p_uniform_buffer: *const DescriptorAddressInfoEXT, + pub p_storage_buffer: *const DescriptorAddressInfoEXT, + pub acceleration_structure: DeviceAddress, +} +impl ::std::default::Default for DescriptorDataEXT { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorGetInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: DescriptorType, + pub data: DescriptorDataEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DescriptorGetInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DescriptorGetInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("data", &"union") + .finish() + } +} +impl ::std::default::Default for DescriptorGetInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: DescriptorType::default(), + data: DescriptorDataEXT::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorGetInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_GET_INFO_EXT; +} +impl DescriptorGetInfoEXT { + pub fn builder<'a>() -> DescriptorGetInfoEXTBuilder<'a> { + DescriptorGetInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorGetInfoEXTBuilder<'a> { + inner: DescriptorGetInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorGetInfoEXTBuilder<'a> { + type Target = DescriptorGetInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorGetInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorGetInfoEXTBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: DescriptorType) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn data(mut self, data: DescriptorDataEXT) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorGetInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for BufferCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for BufferCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl BufferCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + BufferCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: BufferCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = BufferCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, +} +impl ::std::default::Default for ImageCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + } + } +} +unsafe impl TaggedStructure for ImageCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl ImageCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + ImageCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: ImageCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = ImageCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, +} +impl ::std::default::Default for ImageViewCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl ImageViewCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + ImageViewCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: ImageViewCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = ImageViewCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sampler: Sampler, +} +impl ::std::default::Default for SamplerCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sampler: Sampler::default(), + } + } +} +unsafe impl TaggedStructure for SamplerCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl SamplerCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + SamplerCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: SamplerCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = SamplerCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn sampler(mut self, sampler: Sampler) -> Self { + self.inner.sampler = sampler; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureKHR, + pub acceleration_structure_nv: AccelerationStructureNV, +} +impl ::std::default::Default for AccelerationStructureCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureKHR::default(), + acceleration_structure_nv: AccelerationStructureNV::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl AccelerationStructureCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + AccelerationStructureCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: AccelerationStructureCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = AccelerationStructureCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[inline] + pub fn acceleration_structure_nv( + mut self, + acceleration_structure_nv: AccelerationStructureNV, + ) -> Self { + self.inner.acceleration_structure_nv = acceleration_structure_nv; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpaqueCaptureDescriptorDataCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub opaque_capture_descriptor_data: *const c_void, +} +impl ::std::default::Default for OpaqueCaptureDescriptorDataCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + opaque_capture_descriptor_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for OpaqueCaptureDescriptorDataCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; +} +impl OpaqueCaptureDescriptorDataCreateInfoEXT { + pub fn builder<'a>() -> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + OpaqueCaptureDescriptorDataCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + inner: OpaqueCaptureDescriptorDataCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR + for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsAccelerationStructureCreateInfoNV + for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureCreateInfoNV for OpaqueCaptureDescriptorDataCreateInfoEXT {} +impl<'a> ::std::ops::Deref for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + type Target = OpaqueCaptureDescriptorDataCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + #[inline] + pub fn opaque_capture_descriptor_data( + mut self, + opaque_capture_descriptor_data: *const c_void, + ) -> Self { + self.inner.opaque_capture_descriptor_data = opaque_capture_descriptor_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpaqueCaptureDescriptorDataCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderIntegerDotProductFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_integer_dot_product: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_integer_dot_product: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerDotProductFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; +} +impl PhysicalDeviceShaderIntegerDotProductFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + PhysicalDeviceShaderIntegerDotProductFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderIntegerDotProductFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderIntegerDotProductFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + #[inline] + pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self { + self.inner.shader_integer_dot_product = shader_integer_dot_product.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderIntegerDotProductProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub integer_dot_product8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product8_bit_signed_accelerated: Bool32, + pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32, + pub integer_dot_product16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product16_bit_signed_accelerated: Bool32, + pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product32_bit_signed_accelerated: Bool32, + pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product64_bit_signed_accelerated: Bool32, + pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: + Bool32, + pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties { + #[inline] + fn default() -> Self { + Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerDotProductProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; +} +impl PhysicalDeviceShaderIntegerDotProductProperties { + pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + PhysicalDeviceShaderIntegerDotProductPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + inner: PhysicalDeviceShaderIntegerDotProductProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderIntegerDotProductProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + type Target = PhysicalDeviceShaderIntegerDotProductProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + #[inline] + pub fn integer_dot_product8_bit_unsigned_accelerated( + mut self, + integer_dot_product8_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product8_bit_unsigned_accelerated = + integer_dot_product8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_signed_accelerated( + mut self, + integer_dot_product8_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product8_bit_signed_accelerated = + integer_dot_product8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product8_bit_mixed_signedness_accelerated = + integer_dot_product8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_unsigned_accelerated = + integer_dot_product4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_signed_accelerated = + integer_dot_product4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_unsigned_accelerated( + mut self, + integer_dot_product16_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product16_bit_unsigned_accelerated = + integer_dot_product16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_signed_accelerated( + mut self, + integer_dot_product16_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product16_bit_signed_accelerated = + integer_dot_product16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product16_bit_mixed_signedness_accelerated = + integer_dot_product16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_unsigned_accelerated( + mut self, + integer_dot_product32_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product32_bit_unsigned_accelerated = + integer_dot_product32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_signed_accelerated( + mut self, + integer_dot_product32_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product32_bit_signed_accelerated = + integer_dot_product32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product32_bit_mixed_signedness_accelerated = + integer_dot_product32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_unsigned_accelerated( + mut self, + integer_dot_product64_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product64_bit_unsigned_accelerated = + integer_dot_product64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_signed_accelerated( + mut self, + integer_dot_product64_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product64_bit_signed_accelerated = + integer_dot_product64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product64_bit_mixed_signedness_accelerated = + integer_dot_product64_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_signed_accelerated = + integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, + ) -> Self { + self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_signed_accelerated = + integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_signed_accelerated = + integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_signed_accelerated = + integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDrmPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub has_primary: Bool32, + pub has_render: Bool32, + pub primary_major: i64, + pub primary_minor: i64, + pub render_major: i64, + pub render_minor: i64, +} +impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + has_primary: Bool32::default(), + has_render: Bool32::default(), + primary_major: i64::default(), + primary_minor: i64::default(), + render_major: i64::default(), + render_minor: i64::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDrmPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; +} +impl PhysicalDeviceDrmPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + PhysicalDeviceDrmPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDrmPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDrmPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + #[inline] + pub fn has_primary(mut self, has_primary: bool) -> Self { + self.inner.has_primary = has_primary.into(); + self + } + #[inline] + pub fn has_render(mut self, has_render: bool) -> Self { + self.inner.has_render = has_render.into(); + self + } + #[inline] + pub fn primary_major(mut self, primary_major: i64) -> Self { + self.inner.primary_major = primary_major; + self + } + #[inline] + pub fn primary_minor(mut self, primary_minor: i64) -> Self { + self.inner.primary_minor = primary_minor; + self + } + #[inline] + pub fn render_major(mut self, render_major: i64) -> Self { + self.inner.render_major = render_major; + self + } + #[inline] + pub fn render_minor(mut self, render_minor: i64) -> Self { + self.inner.render_minor = render_minor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDrmPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shader_barycentric: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_shader_barycentric: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; +} +impl PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + #[inline] + pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self { + self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + tri_strip_vertex_order_independent_of_provoking_vertex: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; +} +impl PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + #[inline] + pub fn tri_strip_vertex_order_independent_of_provoking_vertex( + mut self, + tri_strip_vertex_order_independent_of_provoking_vertex: bool, + ) -> Self { + self.inner + .tri_strip_vertex_order_independent_of_provoking_vertex = + tri_strip_vertex_order_independent_of_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_motion_blur: Bool32, + pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_motion_blur: Bool32::default(), + ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingMotionBlurFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; +} +impl PhysicalDeviceRayTracingMotionBlurFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceRayTracingMotionBlurFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + #[inline] + pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self { + self.inner.ray_tracing_motion_blur = ray_tracing_motion_blur.into(); + self + } + #[inline] + pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect( + mut self, + ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool, + ) -> Self { + self.inner + .ray_tracing_motion_blur_pipeline_trace_rays_indirect = + ray_tracing_motion_blur_pipeline_trace_rays_indirect.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingMotionBlurFeaturesNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryMotionTrianglesDataNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_data: DeviceOrHostAddressConstKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("vertex_data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_data: DeviceOrHostAddressConstKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryMotionTrianglesDataNV { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; +} +impl AccelerationStructureGeometryMotionTrianglesDataNV { + pub fn builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + AccelerationStructureGeometryMotionTrianglesDataNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + inner: AccelerationStructureGeometryMotionTrianglesDataNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureGeometryMotionTrianglesDataNV +{ +} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + type Target = AccelerationStructureGeometryMotionTrianglesDataNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + #[inline] + pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.vertex_data = vertex_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryMotionTrianglesDataNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureMotionInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_instances: u32, + pub flags: AccelerationStructureMotionInfoFlagsNV, +} +impl ::std::default::Default for AccelerationStructureMotionInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_instances: u32::default(), + flags: AccelerationStructureMotionInfoFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureMotionInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV; +} +impl AccelerationStructureMotionInfoNV { + pub fn builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a> { + AccelerationStructureMotionInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureMotionInfoNVBuilder<'a> { + inner: AccelerationStructureMotionInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR + for AccelerationStructureMotionInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV {} +impl<'a> ::std::ops::Deref for AccelerationStructureMotionInfoNVBuilder<'a> { + type Target = AccelerationStructureMotionInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> { + #[inline] + pub fn max_instances(mut self, max_instances: u32) -> Self { + self.inner.max_instances = max_instances; + self + } + #[inline] + pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureMotionInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SRTDataNV { + pub sx: f32, + pub a: f32, + pub b: f32, + pub pvx: f32, + pub sy: f32, + pub c: f32, + pub pvy: f32, + pub sz: f32, + pub pvz: f32, + pub qx: f32, + pub qy: f32, + pub qz: f32, + pub qw: f32, + pub tx: f32, + pub ty: f32, + pub tz: f32, +} +impl SRTDataNV { + pub fn builder<'a>() -> SRTDataNVBuilder<'a> { + SRTDataNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SRTDataNVBuilder<'a> { + inner: SRTDataNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SRTDataNVBuilder<'a> { + type Target = SRTDataNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SRTDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SRTDataNVBuilder<'a> { + #[inline] + pub fn sx(mut self, sx: f32) -> Self { + self.inner.sx = sx; + self + } + #[inline] + pub fn a(mut self, a: f32) -> Self { + self.inner.a = a; + self + } + #[inline] + pub fn b(mut self, b: f32) -> Self { + self.inner.b = b; + self + } + #[inline] + pub fn pvx(mut self, pvx: f32) -> Self { + self.inner.pvx = pvx; + self + } + #[inline] + pub fn sy(mut self, sy: f32) -> Self { + self.inner.sy = sy; + self + } + #[inline] + pub fn c(mut self, c: f32) -> Self { + self.inner.c = c; + self + } + #[inline] + pub fn pvy(mut self, pvy: f32) -> Self { + self.inner.pvy = pvy; + self + } + #[inline] + pub fn sz(mut self, sz: f32) -> Self { + self.inner.sz = sz; + self + } + #[inline] + pub fn pvz(mut self, pvz: f32) -> Self { + self.inner.pvz = pvz; + self + } + #[inline] + pub fn qx(mut self, qx: f32) -> Self { + self.inner.qx = qx; + self + } + #[inline] + pub fn qy(mut self, qy: f32) -> Self { + self.inner.qy = qy; + self + } + #[inline] + pub fn qz(mut self, qz: f32) -> Self { + self.inner.qz = qz; + self + } + #[inline] + pub fn qw(mut self, qw: f32) -> Self { + self.inner.qw = qw; + self + } + #[inline] + pub fn tx(mut self, tx: f32) -> Self { + self.inner.tx = tx; + self + } + #[inline] + pub fn ty(mut self, ty: f32) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn tz(mut self, tz: f32) -> Self { + self.inner.tz = tz; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SRTDataNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureSRTMotionInstanceNV { + pub transform_t0: SRTDataNV, + pub transform_t1: SRTDataNV, + #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] + pub instance_custom_index_and_mask: Packed24_8, + #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] + pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureMatrixMotionInstanceNV { + pub transform_t0: TransformMatrixKHR, + pub transform_t1: TransformMatrixKHR, + #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] + pub instance_custom_index_and_mask: Packed24_8, + #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] + pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union AccelerationStructureMotionInstanceDataNV { + pub static_instance: AccelerationStructureInstanceKHR, + pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV, + pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV, +} +impl ::std::default::Default for AccelerationStructureMotionInstanceDataNV { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AccelerationStructureMotionInstanceNV { + pub ty: AccelerationStructureMotionInstanceTypeNV, + pub flags: AccelerationStructureMotionInstanceFlagsNV, + pub data: AccelerationStructureMotionInstanceDataNV, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureMotionInstanceNV { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureMotionInstanceNV") + .field("ty", &self.ty) + .field("flags", &self.flags) + .field("data", &"union") + .finish() + } +} +impl AccelerationStructureMotionInstanceNV { + pub fn builder<'a>() -> AccelerationStructureMotionInstanceNVBuilder<'a> { + AccelerationStructureMotionInstanceNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureMotionInstanceNVBuilder<'a> { + inner: AccelerationStructureMotionInstanceNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureMotionInstanceNVBuilder<'a> { + type Target = AccelerationStructureMotionInstanceNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInstanceNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureMotionInstanceNVBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureMotionInstanceNV { + self.inner + } +} +#[doc = ""] +pub type RemoteAddressNV = c_void; +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetRemoteAddressInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for MemoryGetRemoteAddressInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetRemoteAddressInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV; +} +impl MemoryGetRemoteAddressInfoNV { + pub fn builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a> { + MemoryGetRemoteAddressInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetRemoteAddressInfoNVBuilder<'a> { + inner: MemoryGetRemoteAddressInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetRemoteAddressInfoNVBuilder<'a> { + type Target = MemoryGetRemoteAddressInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetRemoteAddressInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetRemoteAddressInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryBufferCollectionFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +unsafe impl TaggedStructure for ImportMemoryBufferCollectionFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; +} +impl ImportMemoryBufferCollectionFUCHSIA { + pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + ImportMemoryBufferCollectionFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + inner: ImportMemoryBufferCollectionFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIABuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA {} +impl<'a> ::std::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + type Target = ImportMemoryBufferCollectionFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.inner.index = index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryBufferCollectionFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionImageCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionImageCreateInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = + StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; +} +impl BufferCollectionImageCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + BufferCollectionImageCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionImageCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIABuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA {} +impl<'a> ::std::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionImageCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.inner.index = index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionImageCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionBufferCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionBufferCreateInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = + StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; +} +impl BufferCollectionBufferCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + BufferCollectionBufferCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionBufferCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIABuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA {} +impl<'a> ::std::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionBufferCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.inner.index = index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionBufferCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection_token: zx_handle_t, +} +impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection_token: zx_handle_t::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionCreateInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; +} +impl BufferCollectionCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> { + BufferCollectionCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> { + #[inline] + pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self { + self.inner.collection_token = collection_token; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionPropertiesFUCHSIA { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, + pub buffer_count: u32, + pub create_info_index: u32, + pub sysmem_pixel_format: u64, + pub format_features: FormatFeatureFlags, + pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, +} +impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + buffer_count: u32::default(), + create_info_index: u32::default(), + sysmem_pixel_format: u64::default(), + format_features: FormatFeatureFlags::default(), + sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionPropertiesFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA; +} +impl BufferCollectionPropertiesFUCHSIA { + pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> { + BufferCollectionPropertiesFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> { + inner: BufferCollectionPropertiesFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> { + type Target = BufferCollectionPropertiesFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[inline] + pub fn buffer_count(mut self, buffer_count: u32) -> Self { + self.inner.buffer_count = buffer_count; + self + } + #[inline] + pub fn create_info_index(mut self, create_info_index: u32) -> Self { + self.inner.create_info_index = create_info_index; + self + } + #[inline] + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.inner.sysmem_pixel_format = sysmem_pixel_format; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { + self.inner.format_features = format_features; + self + } + #[inline] + pub fn sysmem_color_space_index( + mut self, + sysmem_color_space_index: SysmemColorSpaceFUCHSIA, + ) -> Self { + self.inner.sysmem_color_space_index = sysmem_color_space_index; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionPropertiesFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_info: BufferCreateInfo, + pub required_format_features: FormatFeatureFlags, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, +} +impl ::std::default::Default for BufferConstraintsInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + create_info: BufferCreateInfo::default(), + required_format_features: FormatFeatureFlags::default(), + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + } + } +} +unsafe impl TaggedStructure for BufferConstraintsInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA; +} +impl BufferConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> { + BufferConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferConstraintsInfoFUCHSIABuilder<'a> { + inner: BufferConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> { + type Target = BufferConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> { + #[inline] + pub fn create_info(mut self, create_info: BufferCreateInfo) -> Self { + self.inner.create_info = create_info; + self + } + #[inline] + pub fn required_format_features( + mut self, + required_format_features: FormatFeatureFlags, + ) -> Self { + self.inner.required_format_features = required_format_features; + self + } + #[inline] + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + ) -> Self { + self.inner.buffer_collection_constraints = buffer_collection_constraints; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SysmemColorSpaceFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub color_space: u32, +} +impl ::std::default::Default for SysmemColorSpaceFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + color_space: u32::default(), + } + } +} +unsafe impl TaggedStructure for SysmemColorSpaceFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::SYSMEM_COLOR_SPACE_FUCHSIA; +} +impl SysmemColorSpaceFUCHSIA { + pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> { + SysmemColorSpaceFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SysmemColorSpaceFUCHSIABuilder<'a> { + inner: SysmemColorSpaceFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> { + type Target = SysmemColorSpaceFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> { + #[inline] + pub fn color_space(mut self, color_space: u32) -> Self { + self.inner.color_space = color_space; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SysmemColorSpaceFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageFormatConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_create_info: ImageCreateInfo, + pub required_format_features: FormatFeatureFlags, + pub flags: ImageFormatConstraintsFlagsFUCHSIA, + pub sysmem_pixel_format: u64, + pub color_space_count: u32, + pub p_color_spaces: *const SysmemColorSpaceFUCHSIA, +} +impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_create_info: ImageCreateInfo::default(), + required_format_features: FormatFeatureFlags::default(), + flags: ImageFormatConstraintsFlagsFUCHSIA::default(), + sysmem_pixel_format: u64::default(), + color_space_count: u32::default(), + p_color_spaces: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ImageFormatConstraintsInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; +} +impl ImageFormatConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + ImageFormatConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + inner: ImageFormatConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + type Target = ImageFormatConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + #[inline] + pub fn image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self { + self.inner.image_create_info = image_create_info; + self + } + #[inline] + pub fn required_format_features( + mut self, + required_format_features: FormatFeatureFlags, + ) -> Self { + self.inner.required_format_features = required_format_features; + self + } + #[inline] + pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.inner.sysmem_pixel_format = sysmem_pixel_format; + self + } + #[inline] + pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self { + self.inner.color_space_count = color_spaces.len() as _; + self.inner.p_color_spaces = color_spaces.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format_constraints_count: u32, + pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + pub flags: ImageConstraintsInfoFlagsFUCHSIA, +} +impl ::std::default::Default for ImageConstraintsInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format_constraints_count: u32::default(), + p_format_constraints: ::std::ptr::null(), + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + flags: ImageConstraintsInfoFlagsFUCHSIA::default(), + } + } +} +unsafe impl TaggedStructure for ImageConstraintsInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA; +} +impl ImageConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> { + ImageConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageConstraintsInfoFUCHSIABuilder<'a> { + inner: ImageConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> { + type Target = ImageConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> { + #[inline] + pub fn format_constraints( + mut self, + format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA], + ) -> Self { + self.inner.format_constraints_count = format_constraints.len() as _; + self.inner.p_format_constraints = format_constraints.as_ptr(); + self + } + #[inline] + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + ) -> Self { + self.inner.buffer_collection_constraints = buffer_collection_constraints; + self + } + #[inline] + pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_buffer_count: u32, + pub max_buffer_count: u32, + pub min_buffer_count_for_camping: u32, + pub min_buffer_count_for_dedicated_slack: u32, + pub min_buffer_count_for_shared_slack: u32, +} +impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + min_buffer_count: u32::default(), + max_buffer_count: u32::default(), + min_buffer_count_for_camping: u32::default(), + min_buffer_count_for_dedicated_slack: u32::default(), + min_buffer_count_for_shared_slack: u32::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionConstraintsInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; +} +impl BufferCollectionConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + BufferCollectionConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + inner: BufferCollectionConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + #[inline] + pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self { + self.inner.min_buffer_count = min_buffer_count; + self + } + #[inline] + pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self { + self.inner.max_buffer_count = max_buffer_count; + self + } + #[inline] + pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self { + self.inner.min_buffer_count_for_camping = min_buffer_count_for_camping; + self + } + #[inline] + pub fn min_buffer_count_for_dedicated_slack( + mut self, + min_buffer_count_for_dedicated_slack: u32, + ) -> Self { + self.inner.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack; + self + } + #[inline] + pub fn min_buffer_count_for_shared_slack( + mut self, + min_buffer_count_for_shared_slack: u32, + ) -> Self { + self.inner.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_rgba10x6_without_y_cb_cr_sampler: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; +} +impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + #[inline] + pub fn format_rgba10x6_without_y_cb_cr_sampler( + mut self, + format_rgba10x6_without_y_cb_cr_sampler: bool, + ) -> Self { + self.inner.format_rgba10x6_without_y_cb_cr_sampler = + format_rgba10x6_without_y_cb_cr_sampler.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FormatProperties3 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub linear_tiling_features: FormatFeatureFlags2, + pub optimal_tiling_features: FormatFeatureFlags2, + pub buffer_features: FormatFeatureFlags2, +} +impl ::std::default::Default for FormatProperties3 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + linear_tiling_features: FormatFeatureFlags2::default(), + optimal_tiling_features: FormatFeatureFlags2::default(), + buffer_features: FormatFeatureFlags2::default(), + } + } +} +unsafe impl TaggedStructure for FormatProperties3 { + const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_3; +} +impl FormatProperties3 { + pub fn builder<'a>() -> FormatProperties3Builder<'a> { + FormatProperties3Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FormatProperties3Builder<'a> { + inner: FormatProperties3, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for FormatProperties3Builder<'_> {} +unsafe impl ExtendsFormatProperties2 for FormatProperties3 {} +impl<'a> ::std::ops::Deref for FormatProperties3Builder<'a> { + type Target = FormatProperties3; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FormatProperties3Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FormatProperties3Builder<'a> { + #[inline] + pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self { + self.inner.linear_tiling_features = linear_tiling_features; + self + } + #[inline] + pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self { + self.inner.optimal_tiling_features = optimal_tiling_features; + self + } + #[inline] + pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self { + self.inner.buffer_features = buffer_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FormatProperties3 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DrmFormatModifierPropertiesList2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub drm_format_modifier_count: u32, + pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT, +} +impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + drm_format_modifier_count: u32::default(), + p_drm_format_modifier_properties: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DrmFormatModifierPropertiesList2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; +} +impl DrmFormatModifierPropertiesList2EXT { + pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> { + DrmFormatModifierPropertiesList2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> { + inner: DrmFormatModifierPropertiesList2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT {} +impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> { + type Target = DrmFormatModifierPropertiesList2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier_properties( + mut self, + drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT], + ) -> Self { + self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _; + self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrmFormatModifierPropertiesList2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrmFormatModifierProperties2EXT { + pub drm_format_modifier: u64, + pub drm_format_modifier_plane_count: u32, + pub drm_format_modifier_tiling_features: FormatFeatureFlags2, +} +impl DrmFormatModifierProperties2EXT { + pub fn builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a> { + DrmFormatModifierProperties2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierProperties2EXTBuilder<'a> { + inner: DrmFormatModifierProperties2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrmFormatModifierProperties2EXTBuilder<'a> { + type Target = DrmFormatModifierProperties2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierProperties2EXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { + self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self + } + #[inline] + pub fn drm_format_modifier_tiling_features( + mut self, + drm_format_modifier_tiling_features: FormatFeatureFlags2, + ) -> Self { + self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrmFormatModifierProperties2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferFormatProperties2ANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub external_format: u64, + pub format_features: FormatFeatureFlags2, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, +} +impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + external_format: u64::default(), + format_features: FormatFeatureFlags2::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + } + } +} +unsafe impl TaggedStructure for AndroidHardwareBufferFormatProperties2ANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; +} +impl AndroidHardwareBufferFormatProperties2ANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + AndroidHardwareBufferFormatProperties2ANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + inner: AndroidHardwareBufferFormatProperties2ANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'_> +{ +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatProperties2ANDROID +{ +} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferFormatProperties2ANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.inner.external_format = external_format; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self { + self.inner.format_features = format_features; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidHardwareBufferFormatProperties2ANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRenderingCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, +} +impl ::std::default::Default for PipelineRenderingCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRenderingCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RENDERING_CREATE_INFO; +} +impl PipelineRenderingCreateInfo { + pub fn builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a> { + PipelineRenderingCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRenderingCreateInfoBuilder<'a> { + inner: PipelineRenderingCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineRenderingCreateInfoBuilder<'a> { + type Target = PipelineRenderingCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRenderingCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRenderingCreateInfoBuilder<'a> { + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.inner.color_attachment_count = color_attachment_formats.len() as _; + self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self + } + #[inline] + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.inner.depth_attachment_format = depth_attachment_format; + self + } + #[inline] + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.inner.stencil_attachment_format = stencil_attachment_format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRenderingCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderingFlags, + pub render_area: Rect2D, + pub layer_count: u32, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachments: *const RenderingAttachmentInfo, + pub p_depth_attachment: *const RenderingAttachmentInfo, + pub p_stencil_attachment: *const RenderingAttachmentInfo, +} +impl ::std::default::Default for RenderingInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderingFlags::default(), + render_area: Rect2D::default(), + layer_count: u32::default(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachments: ::std::ptr::null(), + p_depth_attachment: ::std::ptr::null(), + p_stencil_attachment: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderingInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_INFO; +} +impl RenderingInfo { + pub fn builder<'a>() -> RenderingInfoBuilder<'a> { + RenderingInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingInfoBuilder<'a> { + inner: RenderingInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderingInfo {} +impl<'a> ::std::ops::Deref for RenderingInfoBuilder<'a> { + type Target = RenderingInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: RenderingFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn render_area(mut self, render_area: Rect2D) -> Self { + self.inner.render_area = render_area; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self { + self.inner.color_attachment_count = color_attachments.len() as _; + self.inner.p_color_attachments = color_attachments.as_ptr(); + self + } + #[inline] + pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo) -> Self { + self.inner.p_depth_attachment = depth_attachment; + self + } + #[inline] + pub fn stencil_attachment(mut self, stencil_attachment: &'a RenderingAttachmentInfo) -> Self { + self.inner.p_stencil_attachment = stencil_attachment; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderingInfo { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingAttachmentInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub resolve_mode: ResolveModeFlags, + pub resolve_image_view: ImageView, + pub resolve_image_layout: ImageLayout, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub clear_value: ClearValue, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderingAttachmentInfo { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderingAttachmentInfo") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("image_view", &self.image_view) + .field("image_layout", &self.image_layout) + .field("resolve_mode", &self.resolve_mode) + .field("resolve_image_view", &self.resolve_image_view) + .field("resolve_image_layout", &self.resolve_image_layout) + .field("load_op", &self.load_op) + .field("store_op", &self.store_op) + .field("clear_value", &"union") + .finish() + } +} +impl ::std::default::Default for RenderingAttachmentInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + resolve_mode: ResolveModeFlags::default(), + resolve_image_view: ImageView::default(), + resolve_image_layout: ImageLayout::default(), + load_op: AttachmentLoadOp::default(), + store_op: AttachmentStoreOp::default(), + clear_value: ClearValue::default(), + } + } +} +unsafe impl TaggedStructure for RenderingAttachmentInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_ATTACHMENT_INFO; +} +impl RenderingAttachmentInfo { + pub fn builder<'a>() -> RenderingAttachmentInfoBuilder<'a> { + RenderingAttachmentInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingAttachmentInfoBuilder<'a> { + inner: RenderingAttachmentInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderingAttachmentInfoBuilder<'a> { + type Target = RenderingAttachmentInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingAttachmentInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingAttachmentInfoBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + #[inline] + pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self { + self.inner.resolve_mode = resolve_mode; + self + } + #[inline] + pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self { + self.inner.resolve_image_view = resolve_image_view; + self + } + #[inline] + pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self { + self.inner.resolve_image_layout = resolve_image_layout; + self + } + #[inline] + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { + self.inner.load_op = load_op; + self + } + #[inline] + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { + self.inner.store_op = store_op; + self + } + #[inline] + pub fn clear_value(mut self, clear_value: ClearValue) -> Self { + self.inner.clear_value = clear_value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderingAttachmentInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingFragmentShadingRateAttachmentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub shading_rate_attachment_texel_size: Extent2D, +} +impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + shading_rate_attachment_texel_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for RenderingFragmentShadingRateAttachmentInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; +} +impl RenderingFragmentShadingRateAttachmentInfoKHR { + pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + RenderingFragmentShadingRateAttachmentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + inner: RenderingFragmentShadingRateAttachmentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR {} +impl<'a> ::std::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + type Target = RenderingFragmentShadingRateAttachmentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + #[inline] + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderingFragmentShadingRateAttachmentInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingFragmentDensityMapAttachmentInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, +} +impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for RenderingFragmentDensityMapAttachmentInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; +} +impl RenderingFragmentDensityMapAttachmentInfoEXT { + pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + RenderingFragmentDensityMapAttachmentInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + inner: RenderingFragmentDensityMapAttachmentInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT {} +impl<'a> ::std::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + type Target = RenderingFragmentDensityMapAttachmentInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderingFragmentDensityMapAttachmentInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDynamicRenderingFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dynamic_rendering: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + dynamic_rendering: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDynamicRenderingFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; +} +impl PhysicalDeviceDynamicRenderingFeatures { + pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + PhysicalDeviceDynamicRenderingFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + inner: PhysicalDeviceDynamicRenderingFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + type Target = PhysicalDeviceDynamicRenderingFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + #[inline] + pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { + self.inner.dynamic_rendering = dynamic_rendering.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDynamicRenderingFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceRenderingInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderingFlags, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, + pub rasterization_samples: SampleCountFlags, +} +impl ::std::default::Default for CommandBufferInheritanceRenderingInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderingFlags::default(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + rasterization_samples: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceRenderingInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; +} +impl CommandBufferInheritanceRenderingInfo { + pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a> { + CommandBufferInheritanceRenderingInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceRenderingInfoBuilder<'a> { + inner: CommandBufferInheritanceRenderingInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceRenderingInfoBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo {} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderingInfoBuilder<'a> { + type Target = CommandBufferInheritanceRenderingInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderingInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceRenderingInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: RenderingFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.inner.color_attachment_count = color_attachment_formats.len() as _; + self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self + } + #[inline] + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.inner.depth_attachment_format = depth_attachment_format; + self + } + #[inline] + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.inner.stencil_attachment_format = stencil_attachment_format; + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceRenderingInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentSampleCountInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub color_attachment_count: u32, + pub p_color_attachment_samples: *const SampleCountFlags, + pub depth_stencil_attachment_samples: SampleCountFlags, +} +impl ::std::default::Default for AttachmentSampleCountInfoAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + color_attachment_count: u32::default(), + p_color_attachment_samples: ::std::ptr::null(), + depth_stencil_attachment_samples: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentSampleCountInfoAMD { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD; +} +impl AttachmentSampleCountInfoAMD { + pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> { + AttachmentSampleCountInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentSampleCountInfoAMDBuilder<'a> { + inner: AttachmentSampleCountInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMDBuilder<'_> {} +unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMDBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD {} +impl<'a> ::std::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> { + type Target = AttachmentSampleCountInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> { + #[inline] + pub fn color_attachment_samples( + mut self, + color_attachment_samples: &'a [SampleCountFlags], + ) -> Self { + self.inner.color_attachment_count = color_attachment_samples.len() as _; + self.inner.p_color_attachment_samples = color_attachment_samples.as_ptr(); + self + } + #[inline] + pub fn depth_stencil_attachment_samples( + mut self, + depth_stencil_attachment_samples: SampleCountFlags, + ) -> Self { + self.inner.depth_stencil_attachment_samples = depth_stencil_attachment_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentSampleCountInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MultiviewPerViewAttributesInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub per_view_attributes: Bool32, + pub per_view_attributes_position_x_only: Bool32, +} +impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + per_view_attributes: Bool32::default(), + per_view_attributes_position_x_only: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for MultiviewPerViewAttributesInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; +} +impl MultiviewPerViewAttributesInfoNVX { + pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> { + MultiviewPerViewAttributesInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> { + inner: MultiviewPerViewAttributesInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX {} +unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX {} +impl<'a> ::std::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> { + type Target = MultiviewPerViewAttributesInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> { + #[inline] + pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self { + self.inner.per_view_attributes = per_view_attributes.into(); + self + } + #[inline] + pub fn per_view_attributes_position_x_only( + mut self, + per_view_attributes_position_x_only: bool, + ) -> Self { + self.inner.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultiviewPerViewAttributesInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageViewMinLodFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_lod: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_lod: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageViewMinLodFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; +} +impl PhysicalDeviceImageViewMinLodFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + PhysicalDeviceImageViewMinLodFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageViewMinLodFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImageViewMinLodFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + #[inline] + pub fn min_lod(mut self, min_lod: bool) -> Self { + self.inner.min_lod = min_lod.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageViewMinLodFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewMinLodCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_lod: f32, +} +impl ::std::default::Default for ImageViewMinLodCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + min_lod: f32::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewMinLodCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; +} +impl ImageViewMinLodCreateInfoEXT { + pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> { + ImageViewMinLodCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> { + inner: ImageViewMinLodCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> { + type Target = ImageViewMinLodCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> { + #[inline] + pub fn min_lod(mut self, min_lod: f32) -> Self { + self.inner.min_lod = min_lod; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewMinLodCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub rasterization_order_color_attachment_access: Bool32, + pub rasterization_order_depth_attachment_access: Bool32, + pub rasterization_order_stencil_attachment_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + rasterization_order_color_attachment_access: Bool32::default(), + rasterization_order_depth_attachment_access: Bool32::default(), + rasterization_order_stencil_attachment_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; +} +impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> { + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT +{ +} +impl<'a> ::std::ops::Deref + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> +{ + type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> { + #[inline] + pub fn rasterization_order_color_attachment_access( + mut self, + rasterization_order_color_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_color_attachment_access = + rasterization_order_color_attachment_access.into(); + self + } + #[inline] + pub fn rasterization_order_depth_attachment_access( + mut self, + rasterization_order_depth_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_depth_attachment_access = + rasterization_order_depth_attachment_access.into(); + self + } + #[inline] + pub fn rasterization_order_stencil_attachment_access( + mut self, + rasterization_order_stencil_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_stencil_attachment_access = + rasterization_order_stencil_attachment_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub linear_color_attachment: Bool32, +} +impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + linear_color_attachment: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceLinearColorAttachmentFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; +} +impl PhysicalDeviceLinearColorAttachmentFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + inner: PhysicalDeviceLinearColorAttachmentFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + #[inline] + pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self { + self.inner.linear_color_attachment = linear_color_attachment.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLinearColorAttachmentFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub graphics_pipeline_library: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + graphics_pipeline_library: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; +} +impl PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + #[inline] + pub fn graphics_pipeline_library(mut self, graphics_pipeline_library: bool) -> Self { + self.inner.graphics_pipeline_library = graphics_pipeline_library.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub graphics_pipeline_library_fast_linking: Bool32, + pub graphics_pipeline_library_independent_interpolation_decoration: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + graphics_pipeline_library_fast_linking: Bool32::default(), + graphics_pipeline_library_independent_interpolation_decoration: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; +} +impl PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + #[inline] + pub fn graphics_pipeline_library_fast_linking( + mut self, + graphics_pipeline_library_fast_linking: bool, + ) -> Self { + self.inner.graphics_pipeline_library_fast_linking = + graphics_pipeline_library_fast_linking.into(); + self + } + #[inline] + pub fn graphics_pipeline_library_independent_interpolation_decoration( + mut self, + graphics_pipeline_library_independent_interpolation_decoration: bool, + ) -> Self { + self.inner + .graphics_pipeline_library_independent_interpolation_decoration = + graphics_pipeline_library_independent_interpolation_decoration.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GraphicsPipelineLibraryCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: GraphicsPipelineLibraryFlagsEXT, +} +impl ::std::default::Default for GraphicsPipelineLibraryCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: GraphicsPipelineLibraryFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for GraphicsPipelineLibraryCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; +} +impl GraphicsPipelineLibraryCreateInfoEXT { + pub fn builder<'a>() -> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + GraphicsPipelineLibraryCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + inner: GraphicsPipelineLibraryCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXT {} +impl<'a> ::std::ops::Deref for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + type Target = GraphicsPipelineLibraryCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: GraphicsPipelineLibraryFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GraphicsPipelineLibraryCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_set_host_mapping: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_set_host_mapping: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; +} +impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + #[inline] + pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self { + self.inner.descriptor_set_host_mapping = descriptor_set_host_mapping.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetBindingReferenceVALVE { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_set_layout: DescriptorSetLayout, + pub binding: u32, +} +impl ::std::default::Default for DescriptorSetBindingReferenceVALVE { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + descriptor_set_layout: DescriptorSetLayout::default(), + binding: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetBindingReferenceVALVE { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; +} +impl DescriptorSetBindingReferenceVALVE { + pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> { + DescriptorSetBindingReferenceVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> { + inner: DescriptorSetBindingReferenceVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> { + type Target = DescriptorSetBindingReferenceVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> { + #[inline] + pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { + self.inner.descriptor_set_layout = descriptor_set_layout; + self + } + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetBindingReferenceVALVE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutHostMappingInfoVALVE { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_offset: usize, + pub descriptor_size: u32, +} +impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_offset: usize::default(), + descriptor_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetLayoutHostMappingInfoVALVE { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; +} +impl DescriptorSetLayoutHostMappingInfoVALVE { + pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + DescriptorSetLayoutHostMappingInfoVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + inner: DescriptorSetLayoutHostMappingInfoVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + type Target = DescriptorSetLayoutHostMappingInfoVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + #[inline] + pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self { + self.inner.descriptor_offset = descriptor_offset; + self + } + #[inline] + pub fn descriptor_size(mut self, descriptor_size: u32) -> Self { + self.inner.descriptor_size = descriptor_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutHostMappingInfoVALVE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_module_identifier: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_module_identifier: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; +} +impl PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderModuleIdentifierFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderModuleIdentifierFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_module_identifier(mut self, shader_module_identifier: bool) -> Self { + self.inner.shader_module_identifier = shader_module_identifier.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], +} +impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_module_identifier_algorithm_uuid: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; +} +impl PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceShaderModuleIdentifierPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + #[inline] + pub fn shader_module_identifier_algorithm_uuid( + mut self, + shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], + ) -> Self { + self.inner.shader_module_identifier_algorithm_uuid = + shader_module_identifier_algorithm_uuid; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub identifier_size: u32, + pub p_identifier: *const u8, +} +impl ::std::default::Default for PipelineShaderStageModuleIdentifierCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + identifier_size: u32::default(), + p_identifier: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineShaderStageModuleIdentifierCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; +} +impl PipelineShaderStageModuleIdentifierCreateInfoEXT { + pub fn builder<'a>() -> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + inner: PipelineShaderStageModuleIdentifierCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageModuleIdentifierCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + type Target = PipelineShaderStageModuleIdentifierCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + #[inline] + pub fn identifier(mut self, identifier: &'a [u8]) -> Self { + self.inner.identifier_size = identifier.len() as _; + self.inner.p_identifier = identifier.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineShaderStageModuleIdentifierCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderModuleIdentifierEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub identifier_size: u32, + pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT], +} +impl ::std::default::Default for ShaderModuleIdentifierEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + identifier_size: u32::default(), + identifier: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ShaderModuleIdentifierEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_IDENTIFIER_EXT; +} +impl ShaderModuleIdentifierEXT { + pub fn builder<'a>() -> ShaderModuleIdentifierEXTBuilder<'a> { + ShaderModuleIdentifierEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderModuleIdentifierEXTBuilder<'a> { + inner: ShaderModuleIdentifierEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderModuleIdentifierEXTBuilder<'a> { + type Target = ShaderModuleIdentifierEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderModuleIdentifierEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderModuleIdentifierEXTBuilder<'a> { + #[inline] + pub fn identifier_size(mut self, identifier_size: u32) -> Self { + self.inner.identifier_size = identifier_size; + self + } + #[inline] + pub fn identifier(mut self, identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]) -> Self { + self.inner.identifier = identifier; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderModuleIdentifierEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCompressionControlEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageCompressionFlagsEXT, + pub compression_control_plane_count: u32, + pub p_fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT, +} +impl ::std::default::Default for ImageCompressionControlEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImageCompressionFlagsEXT::default(), + compression_control_plane_count: u32::default(), + p_fixed_rate_flags: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ImageCompressionControlEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_CONTROL_EXT; +} +impl ImageCompressionControlEXT { + pub fn builder<'a>() -> ImageCompressionControlEXTBuilder<'a> { + ImageCompressionControlEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCompressionControlEXTBuilder<'a> { + inner: ImageCompressionControlEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXT {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXT {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXT {} +impl<'a> ::std::ops::Deref for ImageCompressionControlEXTBuilder<'a> { + type Target = ImageCompressionControlEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCompressionControlEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCompressionControlEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageCompressionFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn fixed_rate_flags( + mut self, + fixed_rate_flags: &'a mut [ImageCompressionFixedRateFlagsEXT], + ) -> Self { + self.inner.compression_control_plane_count = fixed_rate_flags.len() as _; + self.inner.p_fixed_rate_flags = fixed_rate_flags.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCompressionControlEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageCompressionControlFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_control: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageCompressionControlFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_compression_control: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageCompressionControlFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; +} +impl PhysicalDeviceImageCompressionControlFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + PhysicalDeviceImageCompressionControlFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageCompressionControlFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageCompressionControlFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImageCompressionControlFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + #[inline] + pub fn image_compression_control(mut self, image_compression_control: bool) -> Self { + self.inner.image_compression_control = image_compression_control.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageCompressionControlFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCompressionPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_flags: ImageCompressionFlagsEXT, + pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, +} +impl ::std::default::Default for ImageCompressionPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_compression_flags: ImageCompressionFlagsEXT::default(), + image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for ImageCompressionPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT; +} +impl ImageCompressionPropertiesEXT { + pub fn builder<'a>() -> ImageCompressionPropertiesEXTBuilder<'a> { + ImageCompressionPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCompressionPropertiesEXTBuilder<'a> { + inner: ImageCompressionPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT {} +unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT {} +unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXT {} +impl<'a> ::std::ops::Deref for ImageCompressionPropertiesEXTBuilder<'a> { + type Target = ImageCompressionPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCompressionPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCompressionPropertiesEXTBuilder<'a> { + #[inline] + pub fn image_compression_flags( + mut self, + image_compression_flags: ImageCompressionFlagsEXT, + ) -> Self { + self.inner.image_compression_flags = image_compression_flags; + self + } + #[inline] + pub fn image_compression_fixed_rate_flags( + mut self, + image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, + ) -> Self { + self.inner.image_compression_fixed_rate_flags = image_compression_fixed_rate_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCompressionPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_control_swapchain: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_compression_control_swapchain: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; +} +impl PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> +{ + type Target = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + #[inline] + pub fn image_compression_control_swapchain( + mut self, + image_compression_control_swapchain: bool, + ) -> Self { + self.inner.image_compression_control_swapchain = image_compression_control_swapchain.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageSubresource2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_subresource: ImageSubresource, +} +impl ::std::default::Default for ImageSubresource2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_subresource: ImageSubresource::default(), + } + } +} +unsafe impl TaggedStructure for ImageSubresource2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SUBRESOURCE_2_EXT; +} +impl ImageSubresource2EXT { + pub fn builder<'a>() -> ImageSubresource2EXTBuilder<'a> { + ImageSubresource2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresource2EXTBuilder<'a> { + inner: ImageSubresource2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresource2EXTBuilder<'a> { + type Target = ImageSubresource2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresource2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresource2EXTBuilder<'a> { + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresource) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresource2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubresourceLayout2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subresource_layout: SubresourceLayout, +} +impl ::std::default::Default for SubresourceLayout2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subresource_layout: SubresourceLayout::default(), + } + } +} +unsafe impl TaggedStructure for SubresourceLayout2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_LAYOUT_2_EXT; +} +impl SubresourceLayout2EXT { + pub fn builder<'a>() -> SubresourceLayout2EXTBuilder<'a> { + SubresourceLayout2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubresourceLayout2EXTBuilder<'a> { + inner: SubresourceLayout2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubresourceLayout2EXT {} +impl<'a> ::std::ops::Deref for SubresourceLayout2EXTBuilder<'a> { + type Target = SubresourceLayout2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubresourceLayout2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubresourceLayout2EXTBuilder<'a> { + #[inline] + pub fn subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self { + self.inner.subresource_layout = subresource_layout; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubresourceLayout2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreationControlEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub disallow_merging: Bool32, +} +impl ::std::default::Default for RenderPassCreationControlEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + disallow_merging: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for RenderPassCreationControlEXT { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATION_CONTROL_EXT; +} +impl RenderPassCreationControlEXT { + pub fn builder<'a>() -> RenderPassCreationControlEXTBuilder<'a> { + RenderPassCreationControlEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationControlEXTBuilder<'a> { + inner: RenderPassCreationControlEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXT {} +unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXT {} +impl<'a> ::std::ops::Deref for RenderPassCreationControlEXTBuilder<'a> { + type Target = RenderPassCreationControlEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationControlEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationControlEXTBuilder<'a> { + #[inline] + pub fn disallow_merging(mut self, disallow_merging: bool) -> Self { + self.inner.disallow_merging = disallow_merging.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationControlEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct RenderPassCreationFeedbackInfoEXT { + pub post_merge_subpass_count: u32, +} +impl RenderPassCreationFeedbackInfoEXT { + pub fn builder<'a>() -> RenderPassCreationFeedbackInfoEXTBuilder<'a> { + RenderPassCreationFeedbackInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationFeedbackInfoEXTBuilder<'a> { + inner: RenderPassCreationFeedbackInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackInfoEXTBuilder<'a> { + type Target = RenderPassCreationFeedbackInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationFeedbackInfoEXTBuilder<'a> { + #[inline] + pub fn post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self { + self.inner.post_merge_subpass_count = post_merge_subpass_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationFeedbackInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreationFeedbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT, +} +impl ::std::default::Default for RenderPassCreationFeedbackCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_render_pass_feedback: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for RenderPassCreationFeedbackCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; +} +impl RenderPassCreationFeedbackCreateInfoEXT { + pub fn builder<'a>() -> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + RenderPassCreationFeedbackCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + inner: RenderPassCreationFeedbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + type Target = RenderPassCreationFeedbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + #[inline] + pub fn render_pass_feedback( + mut self, + render_pass_feedback: &'a mut RenderPassCreationFeedbackInfoEXT, + ) -> Self { + self.inner.p_render_pass_feedback = render_pass_feedback; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationFeedbackCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSubpassFeedbackInfoEXT { + pub subpass_merge_status: SubpassMergeStatusEXT, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub post_merge_index: u32, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderPassSubpassFeedbackInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderPassSubpassFeedbackInfoEXT") + .field("subpass_merge_status", &self.subpass_merge_status) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("post_merge_index", &self.post_merge_index) + .finish() + } +} +impl ::std::default::Default for RenderPassSubpassFeedbackInfoEXT { + #[inline] + fn default() -> Self { + Self { + subpass_merge_status: SubpassMergeStatusEXT::default(), + description: unsafe { ::std::mem::zeroed() }, + post_merge_index: u32::default(), + } + } +} +impl RenderPassSubpassFeedbackInfoEXT { + pub fn builder<'a>() -> RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + RenderPassSubpassFeedbackInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + inner: RenderPassSubpassFeedbackInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + type Target = RenderPassSubpassFeedbackInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + #[inline] + pub fn subpass_merge_status(mut self, subpass_merge_status: SubpassMergeStatusEXT) -> Self { + self.inner.subpass_merge_status = subpass_merge_status; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn post_merge_index(mut self, post_merge_index: u32) -> Self { + self.inner.post_merge_index = post_merge_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassSubpassFeedbackInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSubpassFeedbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT, +} +impl ::std::default::Default for RenderPassSubpassFeedbackCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_subpass_feedback: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for RenderPassSubpassFeedbackCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; +} +impl RenderPassSubpassFeedbackCreateInfoEXT { + pub fn builder<'a>() -> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + RenderPassSubpassFeedbackCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + inner: RenderPassSubpassFeedbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + type Target = RenderPassSubpassFeedbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + #[inline] + pub fn subpass_feedback( + mut self, + subpass_feedback: &'a mut RenderPassSubpassFeedbackInfoEXT, + ) -> Self { + self.inner.p_subpass_feedback = subpass_feedback; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassSubpassFeedbackCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subpass_merge_feedback: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subpass_merge_feedback: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; +} +impl PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + #[inline] + pub fn subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self { + self.inner.subpass_merge_feedback = subpass_merge_feedback.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapBuildInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: MicromapTypeEXT, + pub flags: BuildMicromapFlagsEXT, + pub mode: BuildMicromapModeEXT, + pub dst_micromap: MicromapEXT, + pub usage_counts_count: u32, + pub p_usage_counts: *const MicromapUsageEXT, + pub pp_usage_counts: *const *const MicromapUsageEXT, + pub data: DeviceOrHostAddressConstKHR, + pub scratch_data: DeviceOrHostAddressKHR, + pub triangle_array: DeviceOrHostAddressConstKHR, + pub triangle_array_stride: DeviceSize, +} +#[cfg(feature = "debug")] +impl fmt::Debug for MicromapBuildInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("MicromapBuildInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("flags", &self.flags) + .field("mode", &self.mode) + .field("dst_micromap", &self.dst_micromap) + .field("usage_counts_count", &self.usage_counts_count) + .field("p_usage_counts", &self.p_usage_counts) + .field("pp_usage_counts", &self.pp_usage_counts) + .field("data", &"union") + .field("scratch_data", &"union") + .field("triangle_array", &"union") + .field("triangle_array_stride", &self.triangle_array_stride) + .finish() + } +} +impl ::std::default::Default for MicromapBuildInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: MicromapTypeEXT::default(), + flags: BuildMicromapFlagsEXT::default(), + mode: BuildMicromapModeEXT::default(), + dst_micromap: MicromapEXT::default(), + usage_counts_count: u32::default(), + p_usage_counts: ::std::ptr::null(), + pp_usage_counts: ::std::ptr::null(), + data: DeviceOrHostAddressConstKHR::default(), + scratch_data: DeviceOrHostAddressKHR::default(), + triangle_array: DeviceOrHostAddressConstKHR::default(), + triangle_array_stride: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for MicromapBuildInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_INFO_EXT; +} +impl MicromapBuildInfoEXT { + pub fn builder<'a>() -> MicromapBuildInfoEXTBuilder<'a> { + MicromapBuildInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapBuildInfoEXTBuilder<'a> { + inner: MicromapBuildInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapBuildInfoEXTBuilder<'a> { + type Target = MicromapBuildInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapBuildInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapBuildInfoEXTBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: MicromapTypeEXT) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: BuildMicromapFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn mode(mut self, mode: BuildMicromapModeEXT) -> Self { + self.inner.mode = mode; + self + } + #[inline] + pub fn dst_micromap(mut self, dst_micromap: MicromapEXT) -> Self { + self.inner.dst_micromap = dst_micromap; + self + } + #[inline] + pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts.len() as _; + self.inner.p_usage_counts = usage_counts.as_ptr(); + self + } + #[inline] + pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts_ptrs.len() as _; + self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.data = data; + self + } + #[inline] + pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self { + self.inner.scratch_data = scratch_data; + self + } + #[inline] + pub fn triangle_array(mut self, triangle_array: DeviceOrHostAddressConstKHR) -> Self { + self.inner.triangle_array = triangle_array; + self + } + #[inline] + pub fn triangle_array_stride(mut self, triangle_array_stride: DeviceSize) -> Self { + self.inner.triangle_array_stride = triangle_array_stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapBuildInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_flags: MicromapCreateFlagsEXT, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, + pub ty: MicromapTypeEXT, + pub device_address: DeviceAddress, +} +impl ::std::default::Default for MicromapCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + create_flags: MicromapCreateFlagsEXT::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + ty: MicromapTypeEXT::default(), + device_address: DeviceAddress::default(), + } + } +} +unsafe impl TaggedStructure for MicromapCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_CREATE_INFO_EXT; +} +impl MicromapCreateInfoEXT { + pub fn builder<'a>() -> MicromapCreateInfoEXTBuilder<'a> { + MicromapCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapCreateInfoEXTBuilder<'a> { + inner: MicromapCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapCreateInfoEXTBuilder<'a> { + type Target = MicromapCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapCreateInfoEXTBuilder<'a> { + #[inline] + pub fn create_flags(mut self, create_flags: MicromapCreateFlagsEXT) -> Self { + self.inner.create_flags = create_flags; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn ty(mut self, ty: MicromapTypeEXT) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapVersionInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_version_data: *const [u8; 2 * UUID_SIZE], +} +impl ::std::default::Default for MicromapVersionInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_version_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for MicromapVersionInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_VERSION_INFO_EXT; +} +impl MicromapVersionInfoEXT { + pub fn builder<'a>() -> MicromapVersionInfoEXTBuilder<'a> { + MicromapVersionInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapVersionInfoEXTBuilder<'a> { + inner: MicromapVersionInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapVersionInfoEXTBuilder<'a> { + type Target = MicromapVersionInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapVersionInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapVersionInfoEXTBuilder<'a> { + #[inline] + pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self { + self.inner.p_version_data = version_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapVersionInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMicromapInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: MicromapEXT, + pub dst: MicromapEXT, + pub mode: CopyMicromapModeEXT, +} +impl ::std::default::Default for CopyMicromapInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: MicromapEXT::default(), + dst: MicromapEXT::default(), + mode: CopyMicromapModeEXT::default(), + } + } +} +unsafe impl TaggedStructure for CopyMicromapInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_INFO_EXT; +} +impl CopyMicromapInfoEXT { + pub fn builder<'a>() -> CopyMicromapInfoEXTBuilder<'a> { + CopyMicromapInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMicromapInfoEXTBuilder<'a> { + inner: CopyMicromapInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMicromapInfoEXTBuilder<'a> { + type Target = CopyMicromapInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMicromapInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMicromapInfoEXTBuilder<'a> { + #[inline] + pub fn src(mut self, src: MicromapEXT) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: MicromapEXT) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMicromapInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMicromapToMemoryInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: MicromapEXT, + pub dst: DeviceOrHostAddressKHR, + pub mode: CopyMicromapModeEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyMicromapToMemoryInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyMicromapToMemoryInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &self.src) + .field("dst", &"union") + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyMicromapToMemoryInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: MicromapEXT::default(), + dst: DeviceOrHostAddressKHR::default(), + mode: CopyMicromapModeEXT::default(), + } + } +} +unsafe impl TaggedStructure for CopyMicromapToMemoryInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_TO_MEMORY_INFO_EXT; +} +impl CopyMicromapToMemoryInfoEXT { + pub fn builder<'a>() -> CopyMicromapToMemoryInfoEXTBuilder<'a> { + CopyMicromapToMemoryInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMicromapToMemoryInfoEXTBuilder<'a> { + inner: CopyMicromapToMemoryInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMicromapToMemoryInfoEXTBuilder<'a> { + type Target = CopyMicromapToMemoryInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMicromapToMemoryInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMicromapToMemoryInfoEXTBuilder<'a> { + #[inline] + pub fn src(mut self, src: MicromapEXT) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMicromapToMemoryInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMemoryToMicromapInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: DeviceOrHostAddressConstKHR, + pub dst: MicromapEXT, + pub mode: CopyMicromapModeEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyMemoryToMicromapInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyMemoryToMicromapInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &"union") + .field("dst", &self.dst) + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyMemoryToMicromapInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: DeviceOrHostAddressConstKHR::default(), + dst: MicromapEXT::default(), + mode: CopyMicromapModeEXT::default(), + } + } +} +unsafe impl TaggedStructure for CopyMemoryToMicromapInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MEMORY_TO_MICROMAP_INFO_EXT; +} +impl CopyMemoryToMicromapInfoEXT { + pub fn builder<'a>() -> CopyMemoryToMicromapInfoEXTBuilder<'a> { + CopyMemoryToMicromapInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMemoryToMicromapInfoEXTBuilder<'a> { + inner: CopyMemoryToMicromapInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMemoryToMicromapInfoEXTBuilder<'a> { + type Target = CopyMemoryToMicromapInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMemoryToMicromapInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMemoryToMicromapInfoEXTBuilder<'a> { + #[inline] + pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: MicromapEXT) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMemoryToMicromapInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapBuildSizesInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub micromap_size: DeviceSize, + pub build_scratch_size: DeviceSize, + pub discardable: Bool32, +} +impl ::std::default::Default for MicromapBuildSizesInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + micromap_size: DeviceSize::default(), + build_scratch_size: DeviceSize::default(), + discardable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for MicromapBuildSizesInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_SIZES_INFO_EXT; +} +impl MicromapBuildSizesInfoEXT { + pub fn builder<'a>() -> MicromapBuildSizesInfoEXTBuilder<'a> { + MicromapBuildSizesInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapBuildSizesInfoEXTBuilder<'a> { + inner: MicromapBuildSizesInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapBuildSizesInfoEXTBuilder<'a> { + type Target = MicromapBuildSizesInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapBuildSizesInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapBuildSizesInfoEXTBuilder<'a> { + #[inline] + pub fn micromap_size(mut self, micromap_size: DeviceSize) -> Self { + self.inner.micromap_size = micromap_size; + self + } + #[inline] + pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self { + self.inner.build_scratch_size = build_scratch_size; + self + } + #[inline] + pub fn discardable(mut self, discardable: bool) -> Self { + self.inner.discardable = discardable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapBuildSizesInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MicromapUsageEXT { + pub count: u32, + pub subdivision_level: u32, + pub format: u32, +} +impl MicromapUsageEXT { + pub fn builder<'a>() -> MicromapUsageEXTBuilder<'a> { + MicromapUsageEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapUsageEXTBuilder<'a> { + inner: MicromapUsageEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapUsageEXTBuilder<'a> { + type Target = MicromapUsageEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapUsageEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapUsageEXTBuilder<'a> { + #[inline] + pub fn count(mut self, count: u32) -> Self { + self.inner.count = count; + self + } + #[inline] + pub fn subdivision_level(mut self, subdivision_level: u32) -> Self { + self.inner.subdivision_level = subdivision_level; + self + } + #[inline] + pub fn format(mut self, format: u32) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapUsageEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MicromapTriangleEXT { + pub data_offset: u32, + pub subdivision_level: u16, + pub format: u16, +} +impl MicromapTriangleEXT { + pub fn builder<'a>() -> MicromapTriangleEXTBuilder<'a> { + MicromapTriangleEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapTriangleEXTBuilder<'a> { + inner: MicromapTriangleEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapTriangleEXTBuilder<'a> { + type Target = MicromapTriangleEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapTriangleEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapTriangleEXTBuilder<'a> { + #[inline] + pub fn data_offset(mut self, data_offset: u32) -> Self { + self.inner.data_offset = data_offset; + self + } + #[inline] + pub fn subdivision_level(mut self, subdivision_level: u16) -> Self { + self.inner.subdivision_level = subdivision_level; + self + } + #[inline] + pub fn format(mut self, format: u16) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapTriangleEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpacityMicromapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub micromap: Bool32, + pub micromap_capture_replay: Bool32, + pub micromap_host_commands: Bool32, +} +impl ::std::default::Default for PhysicalDeviceOpacityMicromapFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + micromap: Bool32::default(), + micromap_capture_replay: Bool32::default(), + micromap_host_commands: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceOpacityMicromapFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; +} +impl PhysicalDeviceOpacityMicromapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + PhysicalDeviceOpacityMicromapFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceOpacityMicromapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceOpacityMicromapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + #[inline] + pub fn micromap(mut self, micromap: bool) -> Self { + self.inner.micromap = micromap.into(); + self + } + #[inline] + pub fn micromap_capture_replay(mut self, micromap_capture_replay: bool) -> Self { + self.inner.micromap_capture_replay = micromap_capture_replay.into(); + self + } + #[inline] + pub fn micromap_host_commands(mut self, micromap_host_commands: bool) -> Self { + self.inner.micromap_host_commands = micromap_host_commands.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceOpacityMicromapFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpacityMicromapPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_opacity2_state_subdivision_level: u32, + pub max_opacity4_state_subdivision_level: u32, +} +impl ::std::default::Default for PhysicalDeviceOpacityMicromapPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_opacity2_state_subdivision_level: u32::default(), + max_opacity4_state_subdivision_level: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceOpacityMicromapPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; +} +impl PhysicalDeviceOpacityMicromapPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + PhysicalDeviceOpacityMicromapPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceOpacityMicromapPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpacityMicromapPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceOpacityMicromapPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_opacity2_state_subdivision_level( + mut self, + max_opacity2_state_subdivision_level: u32, + ) -> Self { + self.inner.max_opacity2_state_subdivision_level = max_opacity2_state_subdivision_level; + self + } + #[inline] + pub fn max_opacity4_state_subdivision_level( + mut self, + max_opacity4_state_subdivision_level: u32, + ) -> Self { + self.inner.max_opacity4_state_subdivision_level = max_opacity4_state_subdivision_level; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceOpacityMicromapPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureTrianglesOpacityMicromapEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub index_type: IndexType, + pub index_buffer: DeviceOrHostAddressConstKHR, + pub index_stride: DeviceSize, + pub base_triangle: u32, + pub usage_counts_count: u32, + pub p_usage_counts: *const MicromapUsageEXT, + pub pp_usage_counts: *const *const MicromapUsageEXT, + pub micromap: MicromapEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureTrianglesOpacityMicromapEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureTrianglesOpacityMicromapEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("index_type", &self.index_type) + .field("index_buffer", &"union") + .field("index_stride", &self.index_stride) + .field("base_triangle", &self.base_triangle) + .field("usage_counts_count", &self.usage_counts_count) + .field("p_usage_counts", &self.p_usage_counts) + .field("pp_usage_counts", &self.pp_usage_counts) + .field("micromap", &self.micromap) + .finish() + } +} +impl ::std::default::Default for AccelerationStructureTrianglesOpacityMicromapEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + index_type: IndexType::default(), + index_buffer: DeviceOrHostAddressConstKHR::default(), + index_stride: DeviceSize::default(), + base_triangle: u32::default(), + usage_counts_count: u32::default(), + p_usage_counts: ::std::ptr::null(), + pp_usage_counts: ::std::ptr::null(), + micromap: MicromapEXT::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureTrianglesOpacityMicromapEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; +} +impl AccelerationStructureTrianglesOpacityMicromapEXT { + pub fn builder<'a>() -> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + AccelerationStructureTrianglesOpacityMicromapEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + inner: AccelerationStructureTrianglesOpacityMicromapEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureTrianglesOpacityMicromapEXT +{ +} +impl<'a> ::std::ops::Deref for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + type Target = AccelerationStructureTrianglesOpacityMicromapEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[inline] + pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self { + self.inner.index_buffer = index_buffer; + self + } + #[inline] + pub fn index_stride(mut self, index_stride: DeviceSize) -> Self { + self.inner.index_stride = index_stride; + self + } + #[inline] + pub fn base_triangle(mut self, base_triangle: u32) -> Self { + self.inner.base_triangle = base_triangle; + self + } + #[inline] + pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts.len() as _; + self.inner.p_usage_counts = usage_counts.as_ptr(); + self + } + #[inline] + pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts_ptrs.len() as _; + self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn micromap(mut self, micromap: MicromapEXT) -> Self { + self.inner.micromap = micromap; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureTrianglesOpacityMicromapEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelinePropertiesIdentifierEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_identifier: [u8; UUID_SIZE], +} +impl ::std::default::Default for PipelinePropertiesIdentifierEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_identifier: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PipelinePropertiesIdentifierEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT; +} +impl PipelinePropertiesIdentifierEXT { + pub fn builder<'a>() -> PipelinePropertiesIdentifierEXTBuilder<'a> { + PipelinePropertiesIdentifierEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelinePropertiesIdentifierEXTBuilder<'a> { + inner: PipelinePropertiesIdentifierEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelinePropertiesIdentifierEXTBuilder<'a> { + type Target = PipelinePropertiesIdentifierEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelinePropertiesIdentifierEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelinePropertiesIdentifierEXTBuilder<'a> { + #[inline] + pub fn pipeline_identifier(mut self, pipeline_identifier: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_identifier = pipeline_identifier; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelinePropertiesIdentifierEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelinePropertiesFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_properties_identifier: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelinePropertiesFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_properties_identifier: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelinePropertiesFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; +} +impl PhysicalDevicePipelinePropertiesFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + PhysicalDevicePipelinePropertiesFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePipelinePropertiesFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelinePropertiesFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePipelinePropertiesFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + #[inline] + pub fn pipeline_properties_identifier(mut self, pipeline_properties_identifier: bool) -> Self { + self.inner.pipeline_properties_identifier = pipeline_properties_identifier.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelinePropertiesFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_early_and_late_fragment_tests: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_early_and_late_fragment_tests: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; +} +impl PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + pub fn builder<'a>() -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + inner: PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + type Target = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + #[inline] + pub fn shader_early_and_late_fragment_tests( + mut self, + shader_early_and_late_fragment_tests: bool, + ) -> Self { + self.inner.shader_early_and_late_fragment_tests = + shader_early_and_late_fragment_tests.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalObjectCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub export_object_type: ExportMetalObjectTypeFlagsEXT, +} +impl ::std::default::Default for ExportMetalObjectCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + export_object_type: ExportMetalObjectTypeFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for ExportMetalObjectCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT; +} +impl ExportMetalObjectCreateInfoEXT { + pub fn builder<'a>() -> ExportMetalObjectCreateInfoEXTBuilder<'a> { + ExportMetalObjectCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalObjectCreateInfoEXTBuilder<'a> { + inner: ExportMetalObjectCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalObjectCreateInfoEXTBuilder<'a> { + type Target = ExportMetalObjectCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalObjectCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalObjectCreateInfoEXTBuilder<'a> { + #[inline] + pub fn export_object_type(mut self, export_object_type: ExportMetalObjectTypeFlagsEXT) -> Self { + self.inner.export_object_type = export_object_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalObjectCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalObjectsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, +} +impl ::std::default::Default for ExportMetalObjectsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ExportMetalObjectsInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECTS_INFO_EXT; +} +impl ExportMetalObjectsInfoEXT { + pub fn builder<'a>() -> ExportMetalObjectsInfoEXTBuilder<'a> { + ExportMetalObjectsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalObjectsInfoEXTBuilder<'a> { + inner: ExportMetalObjectsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsExportMetalObjectsInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalObjectsInfoEXTBuilder<'a> { + type Target = ExportMetalObjectsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalObjectsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalObjectsInfoEXTBuilder<'a> { + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalObjectsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalDeviceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_device: MTLDevice_id, +} +impl ::std::default::Default for ExportMetalDeviceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mtl_device: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalDeviceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_DEVICE_INFO_EXT; +} +impl ExportMetalDeviceInfoEXT { + pub fn builder<'a>() -> ExportMetalDeviceInfoEXTBuilder<'a> { + ExportMetalDeviceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalDeviceInfoEXTBuilder<'a> { + inner: ExportMetalDeviceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalDeviceInfoEXTBuilder<'a> { + type Target = ExportMetalDeviceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalDeviceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalDeviceInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_device(mut self, mtl_device: MTLDevice_id) -> Self { + self.inner.mtl_device = mtl_device; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalDeviceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalCommandQueueInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue: Queue, + pub mtl_command_queue: MTLCommandQueue_id, +} +impl ::std::default::Default for ExportMetalCommandQueueInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + queue: Queue::default(), + mtl_command_queue: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalCommandQueueInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; +} +impl ExportMetalCommandQueueInfoEXT { + pub fn builder<'a>() -> ExportMetalCommandQueueInfoEXTBuilder<'a> { + ExportMetalCommandQueueInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalCommandQueueInfoEXTBuilder<'a> { + inner: ExportMetalCommandQueueInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalCommandQueueInfoEXTBuilder<'a> { + type Target = ExportMetalCommandQueueInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalCommandQueueInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalCommandQueueInfoEXTBuilder<'a> { + #[inline] + pub fn queue(mut self, queue: Queue) -> Self { + self.inner.queue = queue; + self + } + #[inline] + pub fn mtl_command_queue(mut self, mtl_command_queue: MTLCommandQueue_id) -> Self { + self.inner.mtl_command_queue = mtl_command_queue; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalCommandQueueInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalBufferInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub mtl_buffer: MTLBuffer_id, +} +impl ::std::default::Default for ExportMetalBufferInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + mtl_buffer: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalBufferInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_BUFFER_INFO_EXT; +} +impl ExportMetalBufferInfoEXT { + pub fn builder<'a>() -> ExportMetalBufferInfoEXTBuilder<'a> { + ExportMetalBufferInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalBufferInfoEXTBuilder<'a> { + inner: ExportMetalBufferInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalBufferInfoEXTBuilder<'a> { + type Target = ExportMetalBufferInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalBufferInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalBufferInfoEXTBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { + self.inner.mtl_buffer = mtl_buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalBufferInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalBufferInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_buffer: MTLBuffer_id, +} +impl ::std::default::Default for ImportMetalBufferInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mtl_buffer: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMetalBufferInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_BUFFER_INFO_EXT; +} +impl ImportMetalBufferInfoEXT { + pub fn builder<'a>() -> ImportMetalBufferInfoEXTBuilder<'a> { + ImportMetalBufferInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalBufferInfoEXTBuilder<'a> { + inner: ImportMetalBufferInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalBufferInfoEXTBuilder<'a> { + type Target = ImportMetalBufferInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalBufferInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalBufferInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { + self.inner.mtl_buffer = mtl_buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalBufferInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalTextureInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub image_view: ImageView, + pub buffer_view: BufferView, + pub plane: ImageAspectFlags, + pub mtl_texture: MTLTexture_id, +} +impl ::std::default::Default for ExportMetalTextureInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + image_view: ImageView::default(), + buffer_view: BufferView::default(), + plane: ImageAspectFlags::default(), + mtl_texture: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalTextureInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_TEXTURE_INFO_EXT; +} +impl ExportMetalTextureInfoEXT { + pub fn builder<'a>() -> ExportMetalTextureInfoEXTBuilder<'a> { + ExportMetalTextureInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalTextureInfoEXTBuilder<'a> { + inner: ExportMetalTextureInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalTextureInfoEXTBuilder<'a> { + type Target = ExportMetalTextureInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalTextureInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalTextureInfoEXTBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn buffer_view(mut self, buffer_view: BufferView) -> Self { + self.inner.buffer_view = buffer_view; + self + } + #[inline] + pub fn plane(mut self, plane: ImageAspectFlags) -> Self { + self.inner.plane = plane; + self + } + #[inline] + pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { + self.inner.mtl_texture = mtl_texture; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalTextureInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalTextureInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane: ImageAspectFlags, + pub mtl_texture: MTLTexture_id, +} +impl ::std::default::Default for ImportMetalTextureInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + plane: ImageAspectFlags::default(), + mtl_texture: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMetalTextureInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_TEXTURE_INFO_EXT; +} +impl ImportMetalTextureInfoEXT { + pub fn builder<'a>() -> ImportMetalTextureInfoEXTBuilder<'a> { + ImportMetalTextureInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalTextureInfoEXTBuilder<'a> { + inner: ImportMetalTextureInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalTextureInfoEXTBuilder<'a> { + type Target = ImportMetalTextureInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalTextureInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalTextureInfoEXTBuilder<'a> { + #[inline] + pub fn plane(mut self, plane: ImageAspectFlags) -> Self { + self.inner.plane = plane; + self + } + #[inline] + pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { + self.inner.mtl_texture = mtl_texture; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalTextureInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalIOSurfaceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub io_surface: IOSurfaceRef, +} +impl ::std::default::Default for ExportMetalIOSurfaceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + io_surface: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalIOSurfaceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT; +} +impl ExportMetalIOSurfaceInfoEXT { + pub fn builder<'a>() -> ExportMetalIOSurfaceInfoEXTBuilder<'a> { + ExportMetalIOSurfaceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalIOSurfaceInfoEXTBuilder<'a> { + inner: ExportMetalIOSurfaceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalIOSurfaceInfoEXTBuilder<'a> { + type Target = ExportMetalIOSurfaceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalIOSurfaceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalIOSurfaceInfoEXTBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { + self.inner.io_surface = io_surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalIOSurfaceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalIOSurfaceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub io_surface: IOSurfaceRef, +} +impl ::std::default::Default for ImportMetalIOSurfaceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + io_surface: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMetalIOSurfaceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT; +} +impl ImportMetalIOSurfaceInfoEXT { + pub fn builder<'a>() -> ImportMetalIOSurfaceInfoEXTBuilder<'a> { + ImportMetalIOSurfaceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalIOSurfaceInfoEXTBuilder<'a> { + inner: ImportMetalIOSurfaceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalIOSurfaceInfoEXTBuilder<'a> { + type Target = ImportMetalIOSurfaceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalIOSurfaceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalIOSurfaceInfoEXTBuilder<'a> { + #[inline] + pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { + self.inner.io_surface = io_surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalIOSurfaceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalSharedEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub event: Event, + pub mtl_shared_event: MTLSharedEvent_id, +} +impl ::std::default::Default for ExportMetalSharedEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + event: Event::default(), + mtl_shared_event: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalSharedEventInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT; +} +impl ExportMetalSharedEventInfoEXT { + pub fn builder<'a>() -> ExportMetalSharedEventInfoEXTBuilder<'a> { + ExportMetalSharedEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalSharedEventInfoEXTBuilder<'a> { + inner: ExportMetalSharedEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalSharedEventInfoEXTBuilder<'a> { + type Target = ExportMetalSharedEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalSharedEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalSharedEventInfoEXTBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn event(mut self, event: Event) -> Self { + self.inner.event = event; + self + } + #[inline] + pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { + self.inner.mtl_shared_event = mtl_shared_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalSharedEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalSharedEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_shared_event: MTLSharedEvent_id, +} +impl ::std::default::Default for ImportMetalSharedEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mtl_shared_event: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMetalSharedEventInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT; +} +impl ImportMetalSharedEventInfoEXT { + pub fn builder<'a>() -> ImportMetalSharedEventInfoEXTBuilder<'a> { + ImportMetalSharedEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalSharedEventInfoEXTBuilder<'a> { + inner: ImportMetalSharedEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXT {} +unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalSharedEventInfoEXTBuilder<'a> { + type Target = ImportMetalSharedEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalSharedEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalSharedEventInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { + self.inner.mtl_shared_event = mtl_shared_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalSharedEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub non_seamless_cube_map: Bool32, +} +impl ::std::default::Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + non_seamless_cube_map: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; +} +impl PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + #[inline] + pub fn non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self { + self.inner.non_seamless_cube_map = non_seamless_cube_map.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineRobustnessFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_robustness: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelineRobustnessFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_robustness: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineRobustnessFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; +} +impl PhysicalDevicePipelineRobustnessFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + PhysicalDevicePipelineRobustnessFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePipelineRobustnessFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineRobustnessFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePipelineRobustnessFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + #[inline] + pub fn pipeline_robustness(mut self, pipeline_robustness: bool) -> Self { + self.inner.pipeline_robustness = pipeline_robustness.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineRobustnessFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRobustnessCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub storage_buffers: PipelineRobustnessBufferBehaviorEXT, + pub uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + pub vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + pub images: PipelineRobustnessImageBehaviorEXT, +} +impl ::std::default::Default for PipelineRobustnessCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(), + images: PipelineRobustnessImageBehaviorEXT::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRobustnessCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT; +} +impl PipelineRobustnessCreateInfoEXT { + pub fn builder<'a>() -> PipelineRobustnessCreateInfoEXTBuilder<'a> { + PipelineRobustnessCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRobustnessCreateInfoEXTBuilder<'a> { + inner: PipelineRobustnessCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXT {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXT {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXT {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXT {} +impl<'a> ::std::ops::Deref for PipelineRobustnessCreateInfoEXTBuilder<'a> { + type Target = PipelineRobustnessCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRobustnessCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRobustnessCreateInfoEXTBuilder<'a> { + #[inline] + pub fn storage_buffers(mut self, storage_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.inner.storage_buffers = storage_buffers; + self + } + #[inline] + pub fn uniform_buffers(mut self, uniform_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.inner.uniform_buffers = uniform_buffers; + self + } + #[inline] + pub fn vertex_inputs(mut self, vertex_inputs: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.inner.vertex_inputs = vertex_inputs; + self + } + #[inline] + pub fn images(mut self, images: PipelineRobustnessImageBehaviorEXT) -> Self { + self.inner.images = images; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRobustnessCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineRobustnessPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_images: PipelineRobustnessImageBehaviorEXT, +} +impl ::std::default::Default for PhysicalDevicePipelineRobustnessPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_images: PipelineRobustnessImageBehaviorEXT::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineRobustnessPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; +} +impl PhysicalDevicePipelineRobustnessPropertiesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + PhysicalDevicePipelineRobustnessPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + inner: PhysicalDevicePipelineRobustnessPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePipelineRobustnessPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + type Target = PhysicalDevicePipelineRobustnessPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + #[inline] + pub fn default_robustness_storage_buffers( + mut self, + default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, + ) -> Self { + self.inner.default_robustness_storage_buffers = default_robustness_storage_buffers; + self + } + #[inline] + pub fn default_robustness_uniform_buffers( + mut self, + default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + ) -> Self { + self.inner.default_robustness_uniform_buffers = default_robustness_uniform_buffers; + self + } + #[inline] + pub fn default_robustness_vertex_inputs( + mut self, + default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + ) -> Self { + self.inner.default_robustness_vertex_inputs = default_robustness_vertex_inputs; + self + } + #[inline] + pub fn default_robustness_images( + mut self, + default_robustness_images: PipelineRobustnessImageBehaviorEXT, + ) -> Self { + self.inner.default_robustness_images = default_robustness_images; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineRobustnessPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewSampleWeightCreateInfoQCOM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub filter_center: Offset2D, + pub filter_size: Extent2D, + pub num_phases: u32, +} +impl ::std::default::Default for ImageViewSampleWeightCreateInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + filter_center: Offset2D::default(), + filter_size: Extent2D::default(), + num_phases: u32::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewSampleWeightCreateInfoQCOM { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; +} +impl ImageViewSampleWeightCreateInfoQCOM { + pub fn builder<'a>() -> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + ImageViewSampleWeightCreateInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + inner: ImageViewSampleWeightCreateInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOMBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOM {} +impl<'a> ::std::ops::Deref for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + type Target = ImageViewSampleWeightCreateInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + #[inline] + pub fn filter_center(mut self, filter_center: Offset2D) -> Self { + self.inner.filter_center = filter_center; + self + } + #[inline] + pub fn filter_size(mut self, filter_size: Extent2D) -> Self { + self.inner.filter_size = filter_size; + self + } + #[inline] + pub fn num_phases(mut self, num_phases: u32) -> Self { + self.inner.num_phases = num_phases; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewSampleWeightCreateInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageProcessingFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub texture_sample_weighted: Bool32, + pub texture_box_filter: Bool32, + pub texture_block_match: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageProcessingFeaturesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + texture_sample_weighted: Bool32::default(), + texture_box_filter: Bool32::default(), + texture_block_match: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageProcessingFeaturesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; +} +impl PhysicalDeviceImageProcessingFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + PhysicalDeviceImageProcessingFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceImageProcessingFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessingFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceImageProcessingFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + #[inline] + pub fn texture_sample_weighted(mut self, texture_sample_weighted: bool) -> Self { + self.inner.texture_sample_weighted = texture_sample_weighted.into(); + self + } + #[inline] + pub fn texture_box_filter(mut self, texture_box_filter: bool) -> Self { + self.inner.texture_box_filter = texture_box_filter.into(); + self + } + #[inline] + pub fn texture_block_match(mut self, texture_block_match: bool) -> Self { + self.inner.texture_block_match = texture_block_match.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageProcessingFeaturesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageProcessingPropertiesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_weight_filter_phases: u32, + pub max_weight_filter_dimension: Extent2D, + pub max_block_match_region: Extent2D, + pub max_box_filter_block_size: Extent2D, +} +impl ::std::default::Default for PhysicalDeviceImageProcessingPropertiesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_weight_filter_phases: u32::default(), + max_weight_filter_dimension: Extent2D::default(), + max_block_match_region: Extent2D::default(), + max_box_filter_block_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageProcessingPropertiesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; +} +impl PhysicalDeviceImageProcessingPropertiesQCOM { + pub fn builder<'a>() -> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + PhysicalDeviceImageProcessingPropertiesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + inner: PhysicalDeviceImageProcessingPropertiesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessingPropertiesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + type Target = PhysicalDeviceImageProcessingPropertiesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + #[inline] + pub fn max_weight_filter_phases(mut self, max_weight_filter_phases: u32) -> Self { + self.inner.max_weight_filter_phases = max_weight_filter_phases; + self + } + #[inline] + pub fn max_weight_filter_dimension(mut self, max_weight_filter_dimension: Extent2D) -> Self { + self.inner.max_weight_filter_dimension = max_weight_filter_dimension; + self + } + #[inline] + pub fn max_block_match_region(mut self, max_block_match_region: Extent2D) -> Self { + self.inner.max_block_match_region = max_block_match_region; + self + } + #[inline] + pub fn max_box_filter_block_size(mut self, max_box_filter_block_size: Extent2D) -> Self { + self.inner.max_box_filter_block_size = max_box_filter_block_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageProcessingPropertiesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTilePropertiesFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub tile_properties: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTilePropertiesFeaturesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + tile_properties: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTilePropertiesFeaturesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; +} +impl PhysicalDeviceTilePropertiesFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + PhysicalDeviceTilePropertiesFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceTilePropertiesFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceTilePropertiesFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + #[inline] + pub fn tile_properties(mut self, tile_properties: bool) -> Self { + self.inner.tile_properties = tile_properties.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTilePropertiesFeaturesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct TilePropertiesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub tile_size: Extent3D, + pub apron_size: Extent2D, + pub origin: Offset2D, +} +impl ::std::default::Default for TilePropertiesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + tile_size: Extent3D::default(), + apron_size: Extent2D::default(), + origin: Offset2D::default(), + } + } +} +unsafe impl TaggedStructure for TilePropertiesQCOM { + const STRUCTURE_TYPE: StructureType = StructureType::TILE_PROPERTIES_QCOM; +} +impl TilePropertiesQCOM { + pub fn builder<'a>() -> TilePropertiesQCOMBuilder<'a> { + TilePropertiesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TilePropertiesQCOMBuilder<'a> { + inner: TilePropertiesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for TilePropertiesQCOMBuilder<'a> { + type Target = TilePropertiesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TilePropertiesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TilePropertiesQCOMBuilder<'a> { + #[inline] + pub fn tile_size(mut self, tile_size: Extent3D) -> Self { + self.inner.tile_size = tile_size; + self + } + #[inline] + pub fn apron_size(mut self, apron_size: Extent2D) -> Self { + self.inner.apron_size = apron_size; + self + } + #[inline] + pub fn origin(mut self, origin: Offset2D) -> Self { + self.inner.origin = origin; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TilePropertiesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAmigoProfilingFeaturesSEC { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub amigo_profiling: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAmigoProfilingFeaturesSEC { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + amigo_profiling: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAmigoProfilingFeaturesSEC { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; +} +impl PhysicalDeviceAmigoProfilingFeaturesSEC { + pub fn builder<'a>() -> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + PhysicalDeviceAmigoProfilingFeaturesSECBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + inner: PhysicalDeviceAmigoProfilingFeaturesSEC, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSEC {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSEC {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + type Target = PhysicalDeviceAmigoProfilingFeaturesSEC; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + #[inline] + pub fn amigo_profiling(mut self, amigo_profiling: bool) -> Self { + self.inner.amigo_profiling = amigo_profiling.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAmigoProfilingFeaturesSEC { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AmigoProfilingSubmitInfoSEC { + pub s_type: StructureType, + pub p_next: *const c_void, + pub first_draw_timestamp: u64, + pub swap_buffer_timestamp: u64, +} +impl ::std::default::Default for AmigoProfilingSubmitInfoSEC { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + first_draw_timestamp: u64::default(), + swap_buffer_timestamp: u64::default(), + } + } +} +unsafe impl TaggedStructure for AmigoProfilingSubmitInfoSEC { + const STRUCTURE_TYPE: StructureType = StructureType::AMIGO_PROFILING_SUBMIT_INFO_SEC; +} +impl AmigoProfilingSubmitInfoSEC { + pub fn builder<'a>() -> AmigoProfilingSubmitInfoSECBuilder<'a> { + AmigoProfilingSubmitInfoSECBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AmigoProfilingSubmitInfoSECBuilder<'a> { + inner: AmigoProfilingSubmitInfoSEC, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSECBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSEC {} +impl<'a> ::std::ops::Deref for AmigoProfilingSubmitInfoSECBuilder<'a> { + type Target = AmigoProfilingSubmitInfoSEC; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AmigoProfilingSubmitInfoSECBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AmigoProfilingSubmitInfoSECBuilder<'a> { + #[inline] + pub fn first_draw_timestamp(mut self, first_draw_timestamp: u64) -> Self { + self.inner.first_draw_timestamp = first_draw_timestamp; + self + } + #[inline] + pub fn swap_buffer_timestamp(mut self, swap_buffer_timestamp: u64) -> Self { + self.inner.swap_buffer_timestamp = swap_buffer_timestamp; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AmigoProfilingSubmitInfoSEC { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub attachment_feedback_loop_layout: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + attachment_feedback_loop_layout: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; +} +impl PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + #[inline] + pub fn attachment_feedback_loop_layout( + mut self, + attachment_feedback_loop_layout: bool, + ) -> Self { + self.inner.attachment_feedback_loop_layout = attachment_feedback_loop_layout.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub depth_clamp_zero_one: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthClampZeroOneFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + depth_clamp_zero_one: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDepthClampZeroOneFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; +} +impl PhysicalDeviceDepthClampZeroOneFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDepthClampZeroOneFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClampZeroOneFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDepthClampZeroOneFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + #[inline] + pub fn depth_clamp_zero_one(mut self, depth_clamp_zero_one: bool) -> Self { + self.inner.depth_clamp_zero_one = depth_clamp_zero_one.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDepthClampZeroOneFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAddressBindingReportFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub report_address_binding: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAddressBindingReportFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + report_address_binding: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAddressBindingReportFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; +} +impl PhysicalDeviceAddressBindingReportFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + PhysicalDeviceAddressBindingReportFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceAddressBindingReportFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAddressBindingReportFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceAddressBindingReportFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + #[inline] + pub fn report_address_binding(mut self, report_address_binding: bool) -> Self { + self.inner.report_address_binding = report_address_binding.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAddressBindingReportFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceAddressBindingCallbackDataEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: DeviceAddressBindingFlagsEXT, + pub base_address: DeviceAddress, + pub size: DeviceSize, + pub binding_type: DeviceAddressBindingTypeEXT, +} +impl ::std::default::Default for DeviceAddressBindingCallbackDataEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: DeviceAddressBindingFlagsEXT::default(), + base_address: DeviceAddress::default(), + size: DeviceSize::default(), + binding_type: DeviceAddressBindingTypeEXT::default(), + } + } +} +unsafe impl TaggedStructure for DeviceAddressBindingCallbackDataEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; +} +impl DeviceAddressBindingCallbackDataEXT { + pub fn builder<'a>() -> DeviceAddressBindingCallbackDataEXTBuilder<'a> { + DeviceAddressBindingCallbackDataEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceAddressBindingCallbackDataEXTBuilder<'a> { + inner: DeviceAddressBindingCallbackDataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT + for DeviceAddressBindingCallbackDataEXTBuilder<'_> +{ +} +unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT for DeviceAddressBindingCallbackDataEXT {} +impl<'a> ::std::ops::Deref for DeviceAddressBindingCallbackDataEXTBuilder<'a> { + type Target = DeviceAddressBindingCallbackDataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceAddressBindingCallbackDataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceAddressBindingCallbackDataEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceAddressBindingFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn base_address(mut self, base_address: DeviceAddress) -> Self { + self.inner.base_address = base_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn binding_type(mut self, binding_type: DeviceAddressBindingTypeEXT) -> Self { + self.inner.binding_type = binding_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceAddressBindingCallbackDataEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpticalFlowFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub optical_flow: Bool32, +} +impl ::std::default::Default for PhysicalDeviceOpticalFlowFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + optical_flow: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceOpticalFlowFeaturesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; +} +impl PhysicalDeviceOpticalFlowFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + PhysicalDeviceOpticalFlowFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + inner: PhysicalDeviceOpticalFlowFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceOpticalFlowFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + #[inline] + pub fn optical_flow(mut self, optical_flow: bool) -> Self { + self.inner.optical_flow = optical_flow.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceOpticalFlowFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpticalFlowPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV, + pub supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV, + pub hint_supported: Bool32, + pub cost_supported: Bool32, + pub bidirectional_flow_supported: Bool32, + pub global_flow_supported: Bool32, + pub min_width: u32, + pub min_height: u32, + pub max_width: u32, + pub max_height: u32, + pub max_num_regions_of_interest: u32, +} +impl ::std::default::Default for PhysicalDeviceOpticalFlowPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV::default(), + supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV::default(), + hint_supported: Bool32::default(), + cost_supported: Bool32::default(), + bidirectional_flow_supported: Bool32::default(), + global_flow_supported: Bool32::default(), + min_width: u32::default(), + min_height: u32::default(), + max_width: u32::default(), + max_height: u32::default(), + max_num_regions_of_interest: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceOpticalFlowPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; +} +impl PhysicalDeviceOpticalFlowPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + PhysicalDeviceOpticalFlowPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + inner: PhysicalDeviceOpticalFlowPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceOpticalFlowPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + #[inline] + pub fn supported_output_grid_sizes( + mut self, + supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.inner.supported_output_grid_sizes = supported_output_grid_sizes; + self + } + #[inline] + pub fn supported_hint_grid_sizes( + mut self, + supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.inner.supported_hint_grid_sizes = supported_hint_grid_sizes; + self + } + #[inline] + pub fn hint_supported(mut self, hint_supported: bool) -> Self { + self.inner.hint_supported = hint_supported.into(); + self + } + #[inline] + pub fn cost_supported(mut self, cost_supported: bool) -> Self { + self.inner.cost_supported = cost_supported.into(); + self + } + #[inline] + pub fn bidirectional_flow_supported(mut self, bidirectional_flow_supported: bool) -> Self { + self.inner.bidirectional_flow_supported = bidirectional_flow_supported.into(); + self + } + #[inline] + pub fn global_flow_supported(mut self, global_flow_supported: bool) -> Self { + self.inner.global_flow_supported = global_flow_supported.into(); + self + } + #[inline] + pub fn min_width(mut self, min_width: u32) -> Self { + self.inner.min_width = min_width; + self + } + #[inline] + pub fn min_height(mut self, min_height: u32) -> Self { + self.inner.min_height = min_height; + self + } + #[inline] + pub fn max_width(mut self, max_width: u32) -> Self { + self.inner.max_width = max_width; + self + } + #[inline] + pub fn max_height(mut self, max_height: u32) -> Self { + self.inner.max_height = max_height; + self + } + #[inline] + pub fn max_num_regions_of_interest(mut self, max_num_regions_of_interest: u32) -> Self { + self.inner.max_num_regions_of_interest = max_num_regions_of_interest; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceOpticalFlowPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowImageFormatInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: OpticalFlowUsageFlagsNV, +} +impl ::std::default::Default for OpticalFlowImageFormatInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + usage: OpticalFlowUsageFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowImageFormatInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; +} +impl OpticalFlowImageFormatInfoNV { + pub fn builder<'a>() -> OpticalFlowImageFormatInfoNVBuilder<'a> { + OpticalFlowImageFormatInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowImageFormatInfoNVBuilder<'a> { + inner: OpticalFlowImageFormatInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNV {} +unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNVBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNV {} +impl<'a> ::std::ops::Deref for OpticalFlowImageFormatInfoNVBuilder<'a> { + type Target = OpticalFlowImageFormatInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowImageFormatInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowImageFormatInfoNVBuilder<'a> { + #[inline] + pub fn usage(mut self, usage: OpticalFlowUsageFlagsNV) -> Self { + self.inner.usage = usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowImageFormatInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowImageFormatPropertiesNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, +} +impl ::std::default::Default for OpticalFlowImageFormatPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowImageFormatPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; +} +impl OpticalFlowImageFormatPropertiesNV { + pub fn builder<'a>() -> OpticalFlowImageFormatPropertiesNVBuilder<'a> { + OpticalFlowImageFormatPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowImageFormatPropertiesNVBuilder<'a> { + inner: OpticalFlowImageFormatPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for OpticalFlowImageFormatPropertiesNVBuilder<'a> { + type Target = OpticalFlowImageFormatPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowImageFormatPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowImageFormatPropertiesNVBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowImageFormatPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowSessionCreateInfoNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub width: u32, + pub height: u32, + pub image_format: Format, + pub flow_vector_format: Format, + pub cost_format: Format, + pub output_grid_size: OpticalFlowGridSizeFlagsNV, + pub hint_grid_size: OpticalFlowGridSizeFlagsNV, + pub performance_level: OpticalFlowPerformanceLevelNV, + pub flags: OpticalFlowSessionCreateFlagsNV, +} +impl ::std::default::Default for OpticalFlowSessionCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + width: u32::default(), + height: u32::default(), + image_format: Format::default(), + flow_vector_format: Format::default(), + cost_format: Format::default(), + output_grid_size: OpticalFlowGridSizeFlagsNV::default(), + hint_grid_size: OpticalFlowGridSizeFlagsNV::default(), + performance_level: OpticalFlowPerformanceLevelNV::default(), + flags: OpticalFlowSessionCreateFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowSessionCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_SESSION_CREATE_INFO_NV; +} +impl OpticalFlowSessionCreateInfoNV { + pub fn builder<'a>() -> OpticalFlowSessionCreateInfoNVBuilder<'a> { + OpticalFlowSessionCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowSessionCreateInfoNVBuilder<'a> { + inner: OpticalFlowSessionCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsOpticalFlowSessionCreateInfoNV {} +impl<'a> ::std::ops::Deref for OpticalFlowSessionCreateInfoNVBuilder<'a> { + type Target = OpticalFlowSessionCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowSessionCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowSessionCreateInfoNVBuilder<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn image_format(mut self, image_format: Format) -> Self { + self.inner.image_format = image_format; + self + } + #[inline] + pub fn flow_vector_format(mut self, flow_vector_format: Format) -> Self { + self.inner.flow_vector_format = flow_vector_format; + self + } + #[inline] + pub fn cost_format(mut self, cost_format: Format) -> Self { + self.inner.cost_format = cost_format; + self + } + #[inline] + pub fn output_grid_size(mut self, output_grid_size: OpticalFlowGridSizeFlagsNV) -> Self { + self.inner.output_grid_size = output_grid_size; + self + } + #[inline] + pub fn hint_grid_size(mut self, hint_grid_size: OpticalFlowGridSizeFlagsNV) -> Self { + self.inner.hint_grid_size = hint_grid_size; + self + } + #[inline] + pub fn performance_level(mut self, performance_level: OpticalFlowPerformanceLevelNV) -> Self { + self.inner.performance_level = performance_level; + self + } + #[inline] + pub fn flags(mut self, flags: OpticalFlowSessionCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowSessionCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowSessionCreatePrivateDataInfoNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub id: u32, + pub size: u32, + pub p_private_data: *const c_void, +} +impl ::std::default::Default for OpticalFlowSessionCreatePrivateDataInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + id: u32::default(), + size: u32::default(), + p_private_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowSessionCreatePrivateDataInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; +} +impl OpticalFlowSessionCreatePrivateDataInfoNV { + pub fn builder<'a>() -> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + OpticalFlowSessionCreatePrivateDataInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + inner: OpticalFlowSessionCreatePrivateDataInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsOpticalFlowSessionCreateInfoNV + for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsOpticalFlowSessionCreateInfoNV for OpticalFlowSessionCreatePrivateDataInfoNV {} +impl<'a> ::std::ops::Deref for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + type Target = OpticalFlowSessionCreatePrivateDataInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + #[inline] + pub fn id(mut self, id: u32) -> Self { + self.inner.id = id; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn private_data(mut self, private_data: *const c_void) -> Self { + self.inner.p_private_data = private_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowSessionCreatePrivateDataInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowExecuteInfoNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: OpticalFlowExecuteFlagsNV, + pub region_count: u32, + pub p_regions: *const Rect2D, +} +impl ::std::default::Default for OpticalFlowExecuteInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: OpticalFlowExecuteFlagsNV::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowExecuteInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_EXECUTE_INFO_NV; +} +impl OpticalFlowExecuteInfoNV { + pub fn builder<'a>() -> OpticalFlowExecuteInfoNVBuilder<'a> { + OpticalFlowExecuteInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowExecuteInfoNVBuilder<'a> { + inner: OpticalFlowExecuteInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for OpticalFlowExecuteInfoNVBuilder<'a> { + type Target = OpticalFlowExecuteInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowExecuteInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowExecuteInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: OpticalFlowExecuteFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [Rect2D]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowExecuteInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFaultFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_fault: Bool32, + pub device_fault_vendor_binary: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFaultFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_fault: Bool32::default(), + device_fault_vendor_binary: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFaultFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT; +} +impl PhysicalDeviceFaultFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + PhysicalDeviceFaultFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFaultFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFaultFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + #[inline] + pub fn device_fault(mut self, device_fault: bool) -> Self { + self.inner.device_fault = device_fault.into(); + self + } + #[inline] + pub fn device_fault_vendor_binary(mut self, device_fault_vendor_binary: bool) -> Self { + self.inner.device_fault_vendor_binary = device_fault_vendor_binary.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFaultFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DeviceFaultAddressInfoEXT { + pub address_type: DeviceFaultAddressTypeEXT, + pub reported_address: DeviceAddress, + pub address_precision: DeviceSize, +} +impl DeviceFaultAddressInfoEXT { + pub fn builder<'a>() -> DeviceFaultAddressInfoEXTBuilder<'a> { + DeviceFaultAddressInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultAddressInfoEXTBuilder<'a> { + inner: DeviceFaultAddressInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultAddressInfoEXTBuilder<'a> { + type Target = DeviceFaultAddressInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultAddressInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultAddressInfoEXTBuilder<'a> { + #[inline] + pub fn address_type(mut self, address_type: DeviceFaultAddressTypeEXT) -> Self { + self.inner.address_type = address_type; + self + } + #[inline] + pub fn reported_address(mut self, reported_address: DeviceAddress) -> Self { + self.inner.reported_address = reported_address; + self + } + #[inline] + pub fn address_precision(mut self, address_precision: DeviceSize) -> Self { + self.inner.address_precision = address_precision; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultAddressInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultVendorInfoEXT { + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub vendor_fault_code: u64, + pub vendor_fault_data: u64, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DeviceFaultVendorInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceFaultVendorInfoEXT") + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("vendor_fault_code", &self.vendor_fault_code) + .field("vendor_fault_data", &self.vendor_fault_data) + .finish() + } +} +impl ::std::default::Default for DeviceFaultVendorInfoEXT { + #[inline] + fn default() -> Self { + Self { + description: unsafe { ::std::mem::zeroed() }, + vendor_fault_code: u64::default(), + vendor_fault_data: u64::default(), + } + } +} +impl DeviceFaultVendorInfoEXT { + pub fn builder<'a>() -> DeviceFaultVendorInfoEXTBuilder<'a> { + DeviceFaultVendorInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultVendorInfoEXTBuilder<'a> { + inner: DeviceFaultVendorInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultVendorInfoEXTBuilder<'a> { + type Target = DeviceFaultVendorInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultVendorInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultVendorInfoEXTBuilder<'a> { + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn vendor_fault_code(mut self, vendor_fault_code: u64) -> Self { + self.inner.vendor_fault_code = vendor_fault_code; + self + } + #[inline] + pub fn vendor_fault_data(mut self, vendor_fault_data: u64) -> Self { + self.inner.vendor_fault_data = vendor_fault_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultVendorInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultCountsEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address_info_count: u32, + pub vendor_info_count: u32, + pub vendor_binary_size: DeviceSize, +} +impl ::std::default::Default for DeviceFaultCountsEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address_info_count: u32::default(), + vendor_info_count: u32::default(), + vendor_binary_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for DeviceFaultCountsEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_COUNTS_EXT; +} +impl DeviceFaultCountsEXT { + pub fn builder<'a>() -> DeviceFaultCountsEXTBuilder<'a> { + DeviceFaultCountsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultCountsEXTBuilder<'a> { + inner: DeviceFaultCountsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultCountsEXTBuilder<'a> { + type Target = DeviceFaultCountsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultCountsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultCountsEXTBuilder<'a> { + #[inline] + pub fn address_info_count(mut self, address_info_count: u32) -> Self { + self.inner.address_info_count = address_info_count; + self + } + #[inline] + pub fn vendor_info_count(mut self, vendor_info_count: u32) -> Self { + self.inner.vendor_info_count = vendor_info_count; + self + } + #[inline] + pub fn vendor_binary_size(mut self, vendor_binary_size: DeviceSize) -> Self { + self.inner.vendor_binary_size = vendor_binary_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultCountsEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub p_address_infos: *mut DeviceFaultAddressInfoEXT, + pub p_vendor_infos: *mut DeviceFaultVendorInfoEXT, + pub p_vendor_binary_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DeviceFaultInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceFaultInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("p_address_infos", &self.p_address_infos) + .field("p_vendor_infos", &self.p_vendor_infos) + .field("p_vendor_binary_data", &self.p_vendor_binary_data) + .finish() + } +} +impl ::std::default::Default for DeviceFaultInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + description: unsafe { ::std::mem::zeroed() }, + p_address_infos: ::std::ptr::null_mut(), + p_vendor_infos: ::std::ptr::null_mut(), + p_vendor_binary_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DeviceFaultInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_INFO_EXT; +} +impl DeviceFaultInfoEXT { + pub fn builder<'a>() -> DeviceFaultInfoEXTBuilder<'a> { + DeviceFaultInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultInfoEXTBuilder<'a> { + inner: DeviceFaultInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultInfoEXTBuilder<'a> { + type Target = DeviceFaultInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultInfoEXTBuilder<'a> { + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn address_infos(mut self, address_infos: &'a mut DeviceFaultAddressInfoEXT) -> Self { + self.inner.p_address_infos = address_infos; + self + } + #[inline] + pub fn vendor_infos(mut self, vendor_infos: &'a mut DeviceFaultVendorInfoEXT) -> Self { + self.inner.p_vendor_infos = vendor_infos; + self + } + #[inline] + pub fn vendor_binary_data(mut self, vendor_binary_data: *mut c_void) -> Self { + self.inner.p_vendor_binary_data = vendor_binary_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultVendorBinaryHeaderVersionOneEXT { + pub header_size: u32, + pub header_version: DeviceFaultVendorBinaryHeaderVersionEXT, + pub vendor_id: u32, + pub device_id: u32, + pub driver_version: u32, + pub pipeline_cache_uuid: [u8; UUID_SIZE], + pub application_name_offset: u32, + pub application_version: u32, + pub engine_name_offset: u32, +} +impl ::std::default::Default for DeviceFaultVendorBinaryHeaderVersionOneEXT { + #[inline] + fn default() -> Self { + Self { + header_size: u32::default(), + header_version: DeviceFaultVendorBinaryHeaderVersionEXT::default(), + vendor_id: u32::default(), + device_id: u32::default(), + driver_version: u32::default(), + pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, + application_name_offset: u32::default(), + application_version: u32::default(), + engine_name_offset: u32::default(), + } + } +} +impl DeviceFaultVendorBinaryHeaderVersionOneEXT { + pub fn builder<'a>() -> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + inner: DeviceFaultVendorBinaryHeaderVersionOneEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + type Target = DeviceFaultVendorBinaryHeaderVersionOneEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + #[inline] + pub fn header_size(mut self, header_size: u32) -> Self { + self.inner.header_size = header_size; + self + } + #[inline] + pub fn header_version( + mut self, + header_version: DeviceFaultVendorBinaryHeaderVersionEXT, + ) -> Self { + self.inner.header_version = header_version; + self + } + #[inline] + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.inner.vendor_id = vendor_id; + self + } + #[inline] + pub fn device_id(mut self, device_id: u32) -> Self { + self.inner.device_id = device_id; + self + } + #[inline] + pub fn driver_version(mut self, driver_version: u32) -> Self { + self.inner.driver_version = driver_version; + self + } + #[inline] + pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + #[inline] + pub fn application_name_offset(mut self, application_name_offset: u32) -> Self { + self.inner.application_name_offset = application_name_offset; + self + } + #[inline] + pub fn application_version(mut self, application_version: u32) -> Self { + self.inner.application_version = application_version; + self + } + #[inline] + pub fn engine_name_offset(mut self, engine_name_offset: u32) -> Self { + self.inner.engine_name_offset = engine_name_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultVendorBinaryHeaderVersionOneEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DecompressMemoryRegionNV { + pub src_address: DeviceAddress, + pub dst_address: DeviceAddress, + pub compressed_size: DeviceSize, + pub decompressed_size: DeviceSize, + pub decompression_method: MemoryDecompressionMethodFlagsNV, +} +impl DecompressMemoryRegionNV { + pub fn builder<'a>() -> DecompressMemoryRegionNVBuilder<'a> { + DecompressMemoryRegionNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DecompressMemoryRegionNVBuilder<'a> { + inner: DecompressMemoryRegionNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DecompressMemoryRegionNVBuilder<'a> { + type Target = DecompressMemoryRegionNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DecompressMemoryRegionNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DecompressMemoryRegionNVBuilder<'a> { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.inner.src_address = src_address; + self + } + #[inline] + pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self { + self.inner.dst_address = dst_address; + self + } + #[inline] + pub fn compressed_size(mut self, compressed_size: DeviceSize) -> Self { + self.inner.compressed_size = compressed_size; + self + } + #[inline] + pub fn decompressed_size(mut self, decompressed_size: DeviceSize) -> Self { + self.inner.decompressed_size = decompressed_size; + self + } + #[inline] + pub fn decompression_method( + mut self, + decompression_method: MemoryDecompressionMethodFlagsNV, + ) -> Self { + self.inner.decompression_method = decompression_method; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DecompressMemoryRegionNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_mask: u64, + pub shader_core_count: u32, + pub shader_warps_per_core: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_mask: u64::default(), + shader_core_count: u32::default(), + shader_warps_per_core: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; +} +impl PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + inner: PhysicalDeviceShaderCoreBuiltinsPropertiesARM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + type Target = PhysicalDeviceShaderCoreBuiltinsPropertiesARM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + #[inline] + pub fn shader_core_mask(mut self, shader_core_mask: u64) -> Self { + self.inner.shader_core_mask = shader_core_mask; + self + } + #[inline] + pub fn shader_core_count(mut self, shader_core_count: u32) -> Self { + self.inner.shader_core_count = shader_core_count; + self + } + #[inline] + pub fn shader_warps_per_core(mut self, shader_warps_per_core: u32) -> Self { + self.inner.shader_warps_per_core = shader_warps_per_core; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_builtins: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_builtins: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; +} +impl PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + inner: PhysicalDeviceShaderCoreBuiltinsFeaturesARM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + type Target = PhysicalDeviceShaderCoreBuiltinsFeaturesARM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + #[inline] + pub fn shader_core_builtins(mut self, shader_core_builtins: bool) -> Self { + self.inner.shader_core_builtins = shader_core_builtins.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentModeEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode: PresentModeKHR, +} +impl ::std::default::Default for SurfacePresentModeEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode: PresentModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for SurfacePresentModeEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_EXT; +} +impl SurfacePresentModeEXT { + pub fn builder<'a>() -> SurfacePresentModeEXTBuilder<'a> { + SurfacePresentModeEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfacePresentModeEXTBuilder<'a> { + inner: SurfacePresentModeEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXT {} +impl<'a> ::std::ops::Deref for SurfacePresentModeEXTBuilder<'a> { + type Target = SurfacePresentModeEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfacePresentModeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfacePresentModeEXTBuilder<'a> { + #[inline] + pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self { + self.inner.present_mode = present_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfacePresentModeEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentScalingCapabilitiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_present_scaling: PresentScalingFlagsEXT, + pub supported_present_gravity_x: PresentGravityFlagsEXT, + pub supported_present_gravity_y: PresentGravityFlagsEXT, + pub min_scaled_image_extent: Extent2D, + pub max_scaled_image_extent: Extent2D, +} +impl ::std::default::Default for SurfacePresentScalingCapabilitiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_present_scaling: PresentScalingFlagsEXT::default(), + supported_present_gravity_x: PresentGravityFlagsEXT::default(), + supported_present_gravity_y: PresentGravityFlagsEXT::default(), + min_scaled_image_extent: Extent2D::default(), + max_scaled_image_extent: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for SurfacePresentScalingCapabilitiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; +} +impl SurfacePresentScalingCapabilitiesEXT { + pub fn builder<'a>() -> SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + SurfacePresentScalingCapabilitiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + inner: SurfacePresentScalingCapabilitiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXT {} +impl<'a> ::std::ops::Deref for SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + type Target = SurfacePresentScalingCapabilitiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + #[inline] + pub fn supported_present_scaling( + mut self, + supported_present_scaling: PresentScalingFlagsEXT, + ) -> Self { + self.inner.supported_present_scaling = supported_present_scaling; + self + } + #[inline] + pub fn supported_present_gravity_x( + mut self, + supported_present_gravity_x: PresentGravityFlagsEXT, + ) -> Self { + self.inner.supported_present_gravity_x = supported_present_gravity_x; + self + } + #[inline] + pub fn supported_present_gravity_y( + mut self, + supported_present_gravity_y: PresentGravityFlagsEXT, + ) -> Self { + self.inner.supported_present_gravity_y = supported_present_gravity_y; + self + } + #[inline] + pub fn min_scaled_image_extent(mut self, min_scaled_image_extent: Extent2D) -> Self { + self.inner.min_scaled_image_extent = min_scaled_image_extent; + self + } + #[inline] + pub fn max_scaled_image_extent(mut self, max_scaled_image_extent: Extent2D) -> Self { + self.inner.max_scaled_image_extent = max_scaled_image_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfacePresentScalingCapabilitiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentModeCompatibilityEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode_count: u32, + pub p_present_modes: *mut PresentModeKHR, +} +impl ::std::default::Default for SurfacePresentModeCompatibilityEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode_count: u32::default(), + p_present_modes: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for SurfacePresentModeCompatibilityEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; +} +impl SurfacePresentModeCompatibilityEXT { + pub fn builder<'a>() -> SurfacePresentModeCompatibilityEXTBuilder<'a> { + SurfacePresentModeCompatibilityEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfacePresentModeCompatibilityEXTBuilder<'a> { + inner: SurfacePresentModeCompatibilityEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXTBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXT {} +impl<'a> ::std::ops::Deref for SurfacePresentModeCompatibilityEXTBuilder<'a> { + type Target = SurfacePresentModeCompatibilityEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfacePresentModeCompatibilityEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfacePresentModeCompatibilityEXTBuilder<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a mut [PresentModeKHR]) -> Self { + self.inner.present_mode_count = present_modes.len() as _; + self.inner.p_present_modes = present_modes.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfacePresentModeCompatibilityEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_maintenance1: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_maintenance1: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; +} +impl PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceSwapchainMaintenance1FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceSwapchainMaintenance1FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + #[inline] + pub fn swapchain_maintenance1(mut self, swapchain_maintenance1: bool) -> Self { + self.inner.swapchain_maintenance1 = swapchain_maintenance1.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentFenceInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_count: u32, + pub p_fences: *const Fence, +} +impl ::std::default::Default for SwapchainPresentFenceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_count: u32::default(), + p_fences: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentFenceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_FENCE_INFO_EXT; +} +impl SwapchainPresentFenceInfoEXT { + pub fn builder<'a>() -> SwapchainPresentFenceInfoEXTBuilder<'a> { + SwapchainPresentFenceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentFenceInfoEXTBuilder<'a> { + inner: SwapchainPresentFenceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXTBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainPresentFenceInfoEXTBuilder<'a> { + type Target = SwapchainPresentFenceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentFenceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentFenceInfoEXTBuilder<'a> { + #[inline] + pub fn fences(mut self, fences: &'a [Fence]) -> Self { + self.inner.swapchain_count = fences.len() as _; + self.inner.p_fences = fences.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentFenceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentModesCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode_count: u32, + pub p_present_modes: *const PresentModeKHR, +} +impl ::std::default::Default for SwapchainPresentModesCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode_count: u32::default(), + p_present_modes: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentModesCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT; +} +impl SwapchainPresentModesCreateInfoEXT { + pub fn builder<'a>() -> SwapchainPresentModesCreateInfoEXTBuilder<'a> { + SwapchainPresentModesCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentModesCreateInfoEXTBuilder<'a> { + inner: SwapchainPresentModesCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainPresentModesCreateInfoEXTBuilder<'a> { + type Target = SwapchainPresentModesCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentModesCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentModesCreateInfoEXTBuilder<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self { + self.inner.present_mode_count = present_modes.len() as _; + self.inner.p_present_modes = present_modes.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentModesCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentModeInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_count: u32, + pub p_present_modes: *const PresentModeKHR, +} +impl ::std::default::Default for SwapchainPresentModeInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_count: u32::default(), + p_present_modes: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentModeInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODE_INFO_EXT; +} +impl SwapchainPresentModeInfoEXT { + pub fn builder<'a>() -> SwapchainPresentModeInfoEXTBuilder<'a> { + SwapchainPresentModeInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentModeInfoEXTBuilder<'a> { + inner: SwapchainPresentModeInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXTBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainPresentModeInfoEXTBuilder<'a> { + type Target = SwapchainPresentModeInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentModeInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentModeInfoEXTBuilder<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self { + self.inner.swapchain_count = present_modes.len() as _; + self.inner.p_present_modes = present_modes.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentModeInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentScalingCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub scaling_behavior: PresentScalingFlagsEXT, + pub present_gravity_x: PresentGravityFlagsEXT, + pub present_gravity_y: PresentGravityFlagsEXT, +} +impl ::std::default::Default for SwapchainPresentScalingCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + scaling_behavior: PresentScalingFlagsEXT::default(), + present_gravity_x: PresentGravityFlagsEXT::default(), + present_gravity_y: PresentGravityFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentScalingCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT; +} +impl SwapchainPresentScalingCreateInfoEXT { + pub fn builder<'a>() -> SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + SwapchainPresentScalingCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + inner: SwapchainPresentScalingCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + type Target = SwapchainPresentScalingCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + #[inline] + pub fn scaling_behavior(mut self, scaling_behavior: PresentScalingFlagsEXT) -> Self { + self.inner.scaling_behavior = scaling_behavior; + self + } + #[inline] + pub fn present_gravity_x(mut self, present_gravity_x: PresentGravityFlagsEXT) -> Self { + self.inner.present_gravity_x = present_gravity_x; + self + } + #[inline] + pub fn present_gravity_y(mut self, present_gravity_y: PresentGravityFlagsEXT) -> Self { + self.inner.present_gravity_y = present_gravity_y; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentScalingCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ReleaseSwapchainImagesInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub image_index_count: u32, + pub p_image_indices: *const u32, +} +impl ::std::default::Default for ReleaseSwapchainImagesInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + image_index_count: u32::default(), + p_image_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ReleaseSwapchainImagesInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT; +} +impl ReleaseSwapchainImagesInfoEXT { + pub fn builder<'a>() -> ReleaseSwapchainImagesInfoEXTBuilder<'a> { + ReleaseSwapchainImagesInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ReleaseSwapchainImagesInfoEXTBuilder<'a> { + inner: ReleaseSwapchainImagesInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ReleaseSwapchainImagesInfoEXTBuilder<'a> { + type Target = ReleaseSwapchainImagesInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ReleaseSwapchainImagesInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ReleaseSwapchainImagesInfoEXTBuilder<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.inner.swapchain = swapchain; + self + } + #[inline] + pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self { + self.inner.image_index_count = image_indices.len() as _; + self.inner.p_image_indices = image_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ReleaseSwapchainImagesInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_invocation_reorder: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_invocation_reorder: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; +} +impl PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + inner: PhysicalDeviceRayTracingInvocationReorderFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceRayTracingInvocationReorderFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + #[inline] + pub fn ray_tracing_invocation_reorder(mut self, ray_tracing_invocation_reorder: bool) -> Self { + self.inner.ray_tracing_invocation_reorder = ray_tracing_invocation_reorder.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV, +} +impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_invocation_reorder_reordering_hint: + RayTracingInvocationReorderModeNV::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; +} +impl PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + inner: PhysicalDeviceRayTracingInvocationReorderPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingInvocationReorderPropertiesNV +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceRayTracingInvocationReorderPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + #[inline] + pub fn ray_tracing_invocation_reorder_reordering_hint( + mut self, + ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV, + ) -> Self { + self.inner.ray_tracing_invocation_reorder_reordering_hint = + ray_tracing_invocation_reorder_reordering_hint; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DirectDriverLoadingInfoLUNARG { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: DirectDriverLoadingFlagsLUNARG, + pub pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DirectDriverLoadingInfoLUNARG { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DirectDriverLoadingInfoLUNARG") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field( + "pfn_get_instance_proc_addr", + &(self.pfn_get_instance_proc_addr.map(|x| x as *const ())), + ) + .finish() + } +} +impl ::std::default::Default for DirectDriverLoadingInfoLUNARG { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: DirectDriverLoadingFlagsLUNARG::default(), + pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG::default(), + } + } +} +unsafe impl TaggedStructure for DirectDriverLoadingInfoLUNARG { + const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_INFO_LUNARG; +} +impl DirectDriverLoadingInfoLUNARG { + pub fn builder<'a>() -> DirectDriverLoadingInfoLUNARGBuilder<'a> { + DirectDriverLoadingInfoLUNARGBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DirectDriverLoadingInfoLUNARGBuilder<'a> { + inner: DirectDriverLoadingInfoLUNARG, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DirectDriverLoadingInfoLUNARGBuilder<'a> { + type Target = DirectDriverLoadingInfoLUNARG; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DirectDriverLoadingInfoLUNARGBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DirectDriverLoadingInfoLUNARGBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DirectDriverLoadingFlagsLUNARG) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pfn_get_instance_proc_addr( + mut self, + pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG, + ) -> Self { + self.inner.pfn_get_instance_proc_addr = pfn_get_instance_proc_addr; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DirectDriverLoadingInfoLUNARG { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DirectDriverLoadingListLUNARG { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub mode: DirectDriverLoadingModeLUNARG, + pub driver_count: u32, + pub p_drivers: *const DirectDriverLoadingInfoLUNARG, +} +impl ::std::default::Default for DirectDriverLoadingListLUNARG { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + mode: DirectDriverLoadingModeLUNARG::default(), + driver_count: u32::default(), + p_drivers: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DirectDriverLoadingListLUNARG { + const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_LIST_LUNARG; +} +impl DirectDriverLoadingListLUNARG { + pub fn builder<'a>() -> DirectDriverLoadingListLUNARGBuilder<'a> { + DirectDriverLoadingListLUNARGBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DirectDriverLoadingListLUNARGBuilder<'a> { + inner: DirectDriverLoadingListLUNARG, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARGBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARG {} +impl<'a> ::std::ops::Deref for DirectDriverLoadingListLUNARGBuilder<'a> { + type Target = DirectDriverLoadingListLUNARG; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DirectDriverLoadingListLUNARGBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DirectDriverLoadingListLUNARGBuilder<'a> { + #[inline] + pub fn mode(mut self, mode: DirectDriverLoadingModeLUNARG) -> Self { + self.inner.mode = mode; + self + } + #[inline] + pub fn drivers(mut self, drivers: &'a [DirectDriverLoadingInfoLUNARG]) -> Self { + self.inner.driver_count = drivers.len() as _; + self.inner.p_drivers = drivers.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DirectDriverLoadingListLUNARG { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multiview_per_view_viewports: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multiview_per_view_viewports: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; +} +impl PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + #[inline] + pub fn multiview_per_view_viewports(mut self, multiview_per_view_viewports: bool) -> Self { + self.inner.multiview_per_view_viewports = multiview_per_view_viewports.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + self.inner + } +} diff --git a/third_party/rust/ash/src/vk/enums.rs b/third_party/rust/ash/src/vk/enums.rs new file mode 100644 index 0000000000..a27a55b40c --- /dev/null +++ b/third_party/rust/ash/src/vk/enums.rs @@ -0,0 +1,2917 @@ +use std::fmt; +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ImageLayout(pub(crate) i32); +impl ImageLayout { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ImageLayout { + #[doc = "Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)"] + pub const UNDEFINED: Self = Self(0); + #[doc = "General layout when image can be used for any kind of access"] + pub const GENERAL: Self = Self(1); + #[doc = "Optimal layout when image is only used for color attachment read/write"] + pub const COLOR_ATTACHMENT_OPTIMAL: Self = Self(2); + #[doc = "Optimal layout when image is only used for depth/stencil attachment read/write"] + pub const DEPTH_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(3); + #[doc = "Optimal layout when image is used for read only depth/stencil attachment and shader access"] + pub const DEPTH_STENCIL_READ_ONLY_OPTIMAL: Self = Self(4); + #[doc = "Optimal layout when image is used for read only shader access"] + pub const SHADER_READ_ONLY_OPTIMAL: Self = Self(5); + #[doc = "Optimal layout when image is used only as source of transfer operations"] + pub const TRANSFER_SRC_OPTIMAL: Self = Self(6); + #[doc = "Optimal layout when image is used only as destination of transfer operations"] + pub const TRANSFER_DST_OPTIMAL: Self = Self(7); + #[doc = "Initial layout used when the data is populated by the CPU"] + pub const PREINITIALIZED: Self = Self(8); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AttachmentLoadOp(pub(crate) i32); +impl AttachmentLoadOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AttachmentLoadOp { + pub const LOAD: Self = Self(0); + pub const CLEAR: Self = Self(1); + pub const DONT_CARE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AttachmentStoreOp(pub(crate) i32); +impl AttachmentStoreOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AttachmentStoreOp { + pub const STORE: Self = Self(0); + pub const DONT_CARE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ImageType(pub(crate) i32); +impl ImageType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ImageType { + pub const TYPE_1D: Self = Self(0); + pub const TYPE_2D: Self = Self(1); + pub const TYPE_3D: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ImageTiling(pub(crate) i32); +impl ImageTiling { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ImageTiling { + pub const OPTIMAL: Self = Self(0); + pub const LINEAR: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ImageViewType(pub(crate) i32); +impl ImageViewType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ImageViewType { + pub const TYPE_1D: Self = Self(0); + pub const TYPE_2D: Self = Self(1); + pub const TYPE_3D: Self = Self(2); + pub const CUBE: Self = Self(3); + pub const TYPE_1D_ARRAY: Self = Self(4); + pub const TYPE_2D_ARRAY: Self = Self(5); + pub const CUBE_ARRAY: Self = Self(6); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CommandBufferLevel(pub(crate) i32); +impl CommandBufferLevel { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CommandBufferLevel { + pub const PRIMARY: Self = Self(0); + pub const SECONDARY: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ComponentSwizzle(pub(crate) i32); +impl ComponentSwizzle { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ComponentSwizzle { + pub const IDENTITY: Self = Self(0); + pub const ZERO: Self = Self(1); + pub const ONE: Self = Self(2); + pub const R: Self = Self(3); + pub const G: Self = Self(4); + pub const B: Self = Self(5); + pub const A: Self = Self(6); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DescriptorType(pub(crate) i32); +impl DescriptorType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DescriptorType { + pub const SAMPLER: Self = Self(0); + pub const COMBINED_IMAGE_SAMPLER: Self = Self(1); + pub const SAMPLED_IMAGE: Self = Self(2); + pub const STORAGE_IMAGE: Self = Self(3); + pub const UNIFORM_TEXEL_BUFFER: Self = Self(4); + pub const STORAGE_TEXEL_BUFFER: Self = Self(5); + pub const UNIFORM_BUFFER: Self = Self(6); + pub const STORAGE_BUFFER: Self = Self(7); + pub const UNIFORM_BUFFER_DYNAMIC: Self = Self(8); + pub const STORAGE_BUFFER_DYNAMIC: Self = Self(9); + pub const INPUT_ATTACHMENT: Self = Self(10); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct QueryType(pub(crate) i32); +impl QueryType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl QueryType { + pub const OCCLUSION: Self = Self(0); + #[doc = "Optional"] + pub const PIPELINE_STATISTICS: Self = Self(1); + pub const TIMESTAMP: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BorderColor(pub(crate) i32); +impl BorderColor { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BorderColor { + pub const FLOAT_TRANSPARENT_BLACK: Self = Self(0); + pub const INT_TRANSPARENT_BLACK: Self = Self(1); + pub const FLOAT_OPAQUE_BLACK: Self = Self(2); + pub const INT_OPAQUE_BLACK: Self = Self(3); + pub const FLOAT_OPAQUE_WHITE: Self = Self(4); + pub const INT_OPAQUE_WHITE: Self = Self(5); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineBindPoint(pub(crate) i32); +impl PipelineBindPoint { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineBindPoint { + pub const GRAPHICS: Self = Self(0); + pub const COMPUTE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineCacheHeaderVersion(pub(crate) i32); +impl PipelineCacheHeaderVersion { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineCacheHeaderVersion { + pub const ONE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PrimitiveTopology(pub(crate) i32); +impl PrimitiveTopology { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PrimitiveTopology { + pub const POINT_LIST: Self = Self(0); + pub const LINE_LIST: Self = Self(1); + pub const LINE_STRIP: Self = Self(2); + pub const TRIANGLE_LIST: Self = Self(3); + pub const TRIANGLE_STRIP: Self = Self(4); + pub const TRIANGLE_FAN: Self = Self(5); + pub const LINE_LIST_WITH_ADJACENCY: Self = Self(6); + pub const LINE_STRIP_WITH_ADJACENCY: Self = Self(7); + pub const TRIANGLE_LIST_WITH_ADJACENCY: Self = Self(8); + pub const TRIANGLE_STRIP_WITH_ADJACENCY: Self = Self(9); + pub const PATCH_LIST: Self = Self(10); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SharingMode(pub(crate) i32); +impl SharingMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SharingMode { + pub const EXCLUSIVE: Self = Self(0); + pub const CONCURRENT: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct IndexType(pub(crate) i32); +impl IndexType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl IndexType { + pub const UINT16: Self = Self(0); + pub const UINT32: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct Filter(pub(crate) i32); +impl Filter { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl Filter { + pub const NEAREST: Self = Self(0); + pub const LINEAR: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerMipmapMode(pub(crate) i32); +impl SamplerMipmapMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerMipmapMode { + #[doc = "Choose nearest mip level"] + pub const NEAREST: Self = Self(0); + #[doc = "Linear filter between mip levels"] + pub const LINEAR: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerAddressMode(pub(crate) i32); +impl SamplerAddressMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerAddressMode { + pub const REPEAT: Self = Self(0); + pub const MIRRORED_REPEAT: Self = Self(1); + pub const CLAMP_TO_EDGE: Self = Self(2); + pub const CLAMP_TO_BORDER: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CompareOp(pub(crate) i32); +impl CompareOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CompareOp { + pub const NEVER: Self = Self(0); + pub const LESS: Self = Self(1); + pub const EQUAL: Self = Self(2); + pub const LESS_OR_EQUAL: Self = Self(3); + pub const GREATER: Self = Self(4); + pub const NOT_EQUAL: Self = Self(5); + pub const GREATER_OR_EQUAL: Self = Self(6); + pub const ALWAYS: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PolygonMode(pub(crate) i32); +impl PolygonMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PolygonMode { + pub const FILL: Self = Self(0); + pub const LINE: Self = Self(1); + pub const POINT: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FrontFace(pub(crate) i32); +impl FrontFace { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FrontFace { + pub const COUNTER_CLOCKWISE: Self = Self(0); + pub const CLOCKWISE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BlendFactor(pub(crate) i32); +impl BlendFactor { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BlendFactor { + pub const ZERO: Self = Self(0); + pub const ONE: Self = Self(1); + pub const SRC_COLOR: Self = Self(2); + pub const ONE_MINUS_SRC_COLOR: Self = Self(3); + pub const DST_COLOR: Self = Self(4); + pub const ONE_MINUS_DST_COLOR: Self = Self(5); + pub const SRC_ALPHA: Self = Self(6); + pub const ONE_MINUS_SRC_ALPHA: Self = Self(7); + pub const DST_ALPHA: Self = Self(8); + pub const ONE_MINUS_DST_ALPHA: Self = Self(9); + pub const CONSTANT_COLOR: Self = Self(10); + pub const ONE_MINUS_CONSTANT_COLOR: Self = Self(11); + pub const CONSTANT_ALPHA: Self = Self(12); + pub const ONE_MINUS_CONSTANT_ALPHA: Self = Self(13); + pub const SRC_ALPHA_SATURATE: Self = Self(14); + pub const SRC1_COLOR: Self = Self(15); + pub const ONE_MINUS_SRC1_COLOR: Self = Self(16); + pub const SRC1_ALPHA: Self = Self(17); + pub const ONE_MINUS_SRC1_ALPHA: Self = Self(18); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BlendOp(pub(crate) i32); +impl BlendOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BlendOp { + pub const ADD: Self = Self(0); + pub const SUBTRACT: Self = Self(1); + pub const REVERSE_SUBTRACT: Self = Self(2); + pub const MIN: Self = Self(3); + pub const MAX: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct StencilOp(pub(crate) i32); +impl StencilOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl StencilOp { + pub const KEEP: Self = Self(0); + pub const ZERO: Self = Self(1); + pub const REPLACE: Self = Self(2); + pub const INCREMENT_AND_CLAMP: Self = Self(3); + pub const DECREMENT_AND_CLAMP: Self = Self(4); + pub const INVERT: Self = Self(5); + pub const INCREMENT_AND_WRAP: Self = Self(6); + pub const DECREMENT_AND_WRAP: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct LogicOp(pub(crate) i32); +impl LogicOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl LogicOp { + pub const CLEAR: Self = Self(0); + pub const AND: Self = Self(1); + pub const AND_REVERSE: Self = Self(2); + pub const COPY: Self = Self(3); + pub const AND_INVERTED: Self = Self(4); + pub const NO_OP: Self = Self(5); + pub const XOR: Self = Self(6); + pub const OR: Self = Self(7); + pub const NOR: Self = Self(8); + pub const EQUIVALENT: Self = Self(9); + pub const INVERT: Self = Self(10); + pub const OR_REVERSE: Self = Self(11); + pub const COPY_INVERTED: Self = Self(12); + pub const OR_INVERTED: Self = Self(13); + pub const NAND: Self = Self(14); + pub const SET: Self = Self(15); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct InternalAllocationType(pub(crate) i32); +impl InternalAllocationType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl InternalAllocationType { + pub const EXECUTABLE: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SystemAllocationScope(pub(crate) i32); +impl SystemAllocationScope { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SystemAllocationScope { + pub const COMMAND: Self = Self(0); + pub const OBJECT: Self = Self(1); + pub const CACHE: Self = Self(2); + pub const DEVICE: Self = Self(3); + pub const INSTANCE: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PhysicalDeviceType(pub(crate) i32); +impl PhysicalDeviceType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PhysicalDeviceType { + pub const OTHER: Self = Self(0); + pub const INTEGRATED_GPU: Self = Self(1); + pub const DISCRETE_GPU: Self = Self(2); + pub const VIRTUAL_GPU: Self = Self(3); + pub const CPU: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VertexInputRate(pub(crate) i32); +impl VertexInputRate { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VertexInputRate { + pub const VERTEX: Self = Self(0); + pub const INSTANCE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct Format(pub(crate) i32); +impl Format { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl Format { + pub const UNDEFINED: Self = Self(0); + pub const R4G4_UNORM_PACK8: Self = Self(1); + pub const R4G4B4A4_UNORM_PACK16: Self = Self(2); + pub const B4G4R4A4_UNORM_PACK16: Self = Self(3); + pub const R5G6B5_UNORM_PACK16: Self = Self(4); + pub const B5G6R5_UNORM_PACK16: Self = Self(5); + pub const R5G5B5A1_UNORM_PACK16: Self = Self(6); + pub const B5G5R5A1_UNORM_PACK16: Self = Self(7); + pub const A1R5G5B5_UNORM_PACK16: Self = Self(8); + pub const R8_UNORM: Self = Self(9); + pub const R8_SNORM: Self = Self(10); + pub const R8_USCALED: Self = Self(11); + pub const R8_SSCALED: Self = Self(12); + pub const R8_UINT: Self = Self(13); + pub const R8_SINT: Self = Self(14); + pub const R8_SRGB: Self = Self(15); + pub const R8G8_UNORM: Self = Self(16); + pub const R8G8_SNORM: Self = Self(17); + pub const R8G8_USCALED: Self = Self(18); + pub const R8G8_SSCALED: Self = Self(19); + pub const R8G8_UINT: Self = Self(20); + pub const R8G8_SINT: Self = Self(21); + pub const R8G8_SRGB: Self = Self(22); + pub const R8G8B8_UNORM: Self = Self(23); + pub const R8G8B8_SNORM: Self = Self(24); + pub const R8G8B8_USCALED: Self = Self(25); + pub const R8G8B8_SSCALED: Self = Self(26); + pub const R8G8B8_UINT: Self = Self(27); + pub const R8G8B8_SINT: Self = Self(28); + pub const R8G8B8_SRGB: Self = Self(29); + pub const B8G8R8_UNORM: Self = Self(30); + pub const B8G8R8_SNORM: Self = Self(31); + pub const B8G8R8_USCALED: Self = Self(32); + pub const B8G8R8_SSCALED: Self = Self(33); + pub const B8G8R8_UINT: Self = Self(34); + pub const B8G8R8_SINT: Self = Self(35); + pub const B8G8R8_SRGB: Self = Self(36); + pub const R8G8B8A8_UNORM: Self = Self(37); + pub const R8G8B8A8_SNORM: Self = Self(38); + pub const R8G8B8A8_USCALED: Self = Self(39); + pub const R8G8B8A8_SSCALED: Self = Self(40); + pub const R8G8B8A8_UINT: Self = Self(41); + pub const R8G8B8A8_SINT: Self = Self(42); + pub const R8G8B8A8_SRGB: Self = Self(43); + pub const B8G8R8A8_UNORM: Self = Self(44); + pub const B8G8R8A8_SNORM: Self = Self(45); + pub const B8G8R8A8_USCALED: Self = Self(46); + pub const B8G8R8A8_SSCALED: Self = Self(47); + pub const B8G8R8A8_UINT: Self = Self(48); + pub const B8G8R8A8_SINT: Self = Self(49); + pub const B8G8R8A8_SRGB: Self = Self(50); + pub const A8B8G8R8_UNORM_PACK32: Self = Self(51); + pub const A8B8G8R8_SNORM_PACK32: Self = Self(52); + pub const A8B8G8R8_USCALED_PACK32: Self = Self(53); + pub const A8B8G8R8_SSCALED_PACK32: Self = Self(54); + pub const A8B8G8R8_UINT_PACK32: Self = Self(55); + pub const A8B8G8R8_SINT_PACK32: Self = Self(56); + pub const A8B8G8R8_SRGB_PACK32: Self = Self(57); + pub const A2R10G10B10_UNORM_PACK32: Self = Self(58); + pub const A2R10G10B10_SNORM_PACK32: Self = Self(59); + pub const A2R10G10B10_USCALED_PACK32: Self = Self(60); + pub const A2R10G10B10_SSCALED_PACK32: Self = Self(61); + pub const A2R10G10B10_UINT_PACK32: Self = Self(62); + pub const A2R10G10B10_SINT_PACK32: Self = Self(63); + pub const A2B10G10R10_UNORM_PACK32: Self = Self(64); + pub const A2B10G10R10_SNORM_PACK32: Self = Self(65); + pub const A2B10G10R10_USCALED_PACK32: Self = Self(66); + pub const A2B10G10R10_SSCALED_PACK32: Self = Self(67); + pub const A2B10G10R10_UINT_PACK32: Self = Self(68); + pub const A2B10G10R10_SINT_PACK32: Self = Self(69); + pub const R16_UNORM: Self = Self(70); + pub const R16_SNORM: Self = Self(71); + pub const R16_USCALED: Self = Self(72); + pub const R16_SSCALED: Self = Self(73); + pub const R16_UINT: Self = Self(74); + pub const R16_SINT: Self = Self(75); + pub const R16_SFLOAT: Self = Self(76); + pub const R16G16_UNORM: Self = Self(77); + pub const R16G16_SNORM: Self = Self(78); + pub const R16G16_USCALED: Self = Self(79); + pub const R16G16_SSCALED: Self = Self(80); + pub const R16G16_UINT: Self = Self(81); + pub const R16G16_SINT: Self = Self(82); + pub const R16G16_SFLOAT: Self = Self(83); + pub const R16G16B16_UNORM: Self = Self(84); + pub const R16G16B16_SNORM: Self = Self(85); + pub const R16G16B16_USCALED: Self = Self(86); + pub const R16G16B16_SSCALED: Self = Self(87); + pub const R16G16B16_UINT: Self = Self(88); + pub const R16G16B16_SINT: Self = Self(89); + pub const R16G16B16_SFLOAT: Self = Self(90); + pub const R16G16B16A16_UNORM: Self = Self(91); + pub const R16G16B16A16_SNORM: Self = Self(92); + pub const R16G16B16A16_USCALED: Self = Self(93); + pub const R16G16B16A16_SSCALED: Self = Self(94); + pub const R16G16B16A16_UINT: Self = Self(95); + pub const R16G16B16A16_SINT: Self = Self(96); + pub const R16G16B16A16_SFLOAT: Self = Self(97); + pub const R32_UINT: Self = Self(98); + pub const R32_SINT: Self = Self(99); + pub const R32_SFLOAT: Self = Self(100); + pub const R32G32_UINT: Self = Self(101); + pub const R32G32_SINT: Self = Self(102); + pub const R32G32_SFLOAT: Self = Self(103); + pub const R32G32B32_UINT: Self = Self(104); + pub const R32G32B32_SINT: Self = Self(105); + pub const R32G32B32_SFLOAT: Self = Self(106); + pub const R32G32B32A32_UINT: Self = Self(107); + pub const R32G32B32A32_SINT: Self = Self(108); + pub const R32G32B32A32_SFLOAT: Self = Self(109); + pub const R64_UINT: Self = Self(110); + pub const R64_SINT: Self = Self(111); + pub const R64_SFLOAT: Self = Self(112); + pub const R64G64_UINT: Self = Self(113); + pub const R64G64_SINT: Self = Self(114); + pub const R64G64_SFLOAT: Self = Self(115); + pub const R64G64B64_UINT: Self = Self(116); + pub const R64G64B64_SINT: Self = Self(117); + pub const R64G64B64_SFLOAT: Self = Self(118); + pub const R64G64B64A64_UINT: Self = Self(119); + pub const R64G64B64A64_SINT: Self = Self(120); + pub const R64G64B64A64_SFLOAT: Self = Self(121); + pub const B10G11R11_UFLOAT_PACK32: Self = Self(122); + pub const E5B9G9R9_UFLOAT_PACK32: Self = Self(123); + pub const D16_UNORM: Self = Self(124); + pub const X8_D24_UNORM_PACK32: Self = Self(125); + pub const D32_SFLOAT: Self = Self(126); + pub const S8_UINT: Self = Self(127); + pub const D16_UNORM_S8_UINT: Self = Self(128); + pub const D24_UNORM_S8_UINT: Self = Self(129); + pub const D32_SFLOAT_S8_UINT: Self = Self(130); + pub const BC1_RGB_UNORM_BLOCK: Self = Self(131); + pub const BC1_RGB_SRGB_BLOCK: Self = Self(132); + pub const BC1_RGBA_UNORM_BLOCK: Self = Self(133); + pub const BC1_RGBA_SRGB_BLOCK: Self = Self(134); + pub const BC2_UNORM_BLOCK: Self = Self(135); + pub const BC2_SRGB_BLOCK: Self = Self(136); + pub const BC3_UNORM_BLOCK: Self = Self(137); + pub const BC3_SRGB_BLOCK: Self = Self(138); + pub const BC4_UNORM_BLOCK: Self = Self(139); + pub const BC4_SNORM_BLOCK: Self = Self(140); + pub const BC5_UNORM_BLOCK: Self = Self(141); + pub const BC5_SNORM_BLOCK: Self = Self(142); + pub const BC6H_UFLOAT_BLOCK: Self = Self(143); + pub const BC6H_SFLOAT_BLOCK: Self = Self(144); + pub const BC7_UNORM_BLOCK: Self = Self(145); + pub const BC7_SRGB_BLOCK: Self = Self(146); + pub const ETC2_R8G8B8_UNORM_BLOCK: Self = Self(147); + pub const ETC2_R8G8B8_SRGB_BLOCK: Self = Self(148); + pub const ETC2_R8G8B8A1_UNORM_BLOCK: Self = Self(149); + pub const ETC2_R8G8B8A1_SRGB_BLOCK: Self = Self(150); + pub const ETC2_R8G8B8A8_UNORM_BLOCK: Self = Self(151); + pub const ETC2_R8G8B8A8_SRGB_BLOCK: Self = Self(152); + pub const EAC_R11_UNORM_BLOCK: Self = Self(153); + pub const EAC_R11_SNORM_BLOCK: Self = Self(154); + pub const EAC_R11G11_UNORM_BLOCK: Self = Self(155); + pub const EAC_R11G11_SNORM_BLOCK: Self = Self(156); + pub const ASTC_4X4_UNORM_BLOCK: Self = Self(157); + pub const ASTC_4X4_SRGB_BLOCK: Self = Self(158); + pub const ASTC_5X4_UNORM_BLOCK: Self = Self(159); + pub const ASTC_5X4_SRGB_BLOCK: Self = Self(160); + pub const ASTC_5X5_UNORM_BLOCK: Self = Self(161); + pub const ASTC_5X5_SRGB_BLOCK: Self = Self(162); + pub const ASTC_6X5_UNORM_BLOCK: Self = Self(163); + pub const ASTC_6X5_SRGB_BLOCK: Self = Self(164); + pub const ASTC_6X6_UNORM_BLOCK: Self = Self(165); + pub const ASTC_6X6_SRGB_BLOCK: Self = Self(166); + pub const ASTC_8X5_UNORM_BLOCK: Self = Self(167); + pub const ASTC_8X5_SRGB_BLOCK: Self = Self(168); + pub const ASTC_8X6_UNORM_BLOCK: Self = Self(169); + pub const ASTC_8X6_SRGB_BLOCK: Self = Self(170); + pub const ASTC_8X8_UNORM_BLOCK: Self = Self(171); + pub const ASTC_8X8_SRGB_BLOCK: Self = Self(172); + pub const ASTC_10X5_UNORM_BLOCK: Self = Self(173); + pub const ASTC_10X5_SRGB_BLOCK: Self = Self(174); + pub const ASTC_10X6_UNORM_BLOCK: Self = Self(175); + pub const ASTC_10X6_SRGB_BLOCK: Self = Self(176); + pub const ASTC_10X8_UNORM_BLOCK: Self = Self(177); + pub const ASTC_10X8_SRGB_BLOCK: Self = Self(178); + pub const ASTC_10X10_UNORM_BLOCK: Self = Self(179); + pub const ASTC_10X10_SRGB_BLOCK: Self = Self(180); + pub const ASTC_12X10_UNORM_BLOCK: Self = Self(181); + pub const ASTC_12X10_SRGB_BLOCK: Self = Self(182); + pub const ASTC_12X12_UNORM_BLOCK: Self = Self(183); + pub const ASTC_12X12_SRGB_BLOCK: Self = Self(184); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct StructureType(pub(crate) i32); +impl StructureType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl StructureType { + pub const APPLICATION_INFO: Self = Self(0); + pub const INSTANCE_CREATE_INFO: Self = Self(1); + pub const DEVICE_QUEUE_CREATE_INFO: Self = Self(2); + pub const DEVICE_CREATE_INFO: Self = Self(3); + pub const SUBMIT_INFO: Self = Self(4); + pub const MEMORY_ALLOCATE_INFO: Self = Self(5); + pub const MAPPED_MEMORY_RANGE: Self = Self(6); + pub const BIND_SPARSE_INFO: Self = Self(7); + pub const FENCE_CREATE_INFO: Self = Self(8); + pub const SEMAPHORE_CREATE_INFO: Self = Self(9); + pub const EVENT_CREATE_INFO: Self = Self(10); + pub const QUERY_POOL_CREATE_INFO: Self = Self(11); + pub const BUFFER_CREATE_INFO: Self = Self(12); + pub const BUFFER_VIEW_CREATE_INFO: Self = Self(13); + pub const IMAGE_CREATE_INFO: Self = Self(14); + pub const IMAGE_VIEW_CREATE_INFO: Self = Self(15); + pub const SHADER_MODULE_CREATE_INFO: Self = Self(16); + pub const PIPELINE_CACHE_CREATE_INFO: Self = Self(17); + pub const PIPELINE_SHADER_STAGE_CREATE_INFO: Self = Self(18); + pub const PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: Self = Self(19); + pub const PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: Self = Self(20); + pub const PIPELINE_TESSELLATION_STATE_CREATE_INFO: Self = Self(21); + pub const PIPELINE_VIEWPORT_STATE_CREATE_INFO: Self = Self(22); + pub const PIPELINE_RASTERIZATION_STATE_CREATE_INFO: Self = Self(23); + pub const PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: Self = Self(24); + pub const PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: Self = Self(25); + pub const PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: Self = Self(26); + pub const PIPELINE_DYNAMIC_STATE_CREATE_INFO: Self = Self(27); + pub const GRAPHICS_PIPELINE_CREATE_INFO: Self = Self(28); + pub const COMPUTE_PIPELINE_CREATE_INFO: Self = Self(29); + pub const PIPELINE_LAYOUT_CREATE_INFO: Self = Self(30); + pub const SAMPLER_CREATE_INFO: Self = Self(31); + pub const DESCRIPTOR_SET_LAYOUT_CREATE_INFO: Self = Self(32); + pub const DESCRIPTOR_POOL_CREATE_INFO: Self = Self(33); + pub const DESCRIPTOR_SET_ALLOCATE_INFO: Self = Self(34); + pub const WRITE_DESCRIPTOR_SET: Self = Self(35); + pub const COPY_DESCRIPTOR_SET: Self = Self(36); + pub const FRAMEBUFFER_CREATE_INFO: Self = Self(37); + pub const RENDER_PASS_CREATE_INFO: Self = Self(38); + pub const COMMAND_POOL_CREATE_INFO: Self = Self(39); + pub const COMMAND_BUFFER_ALLOCATE_INFO: Self = Self(40); + pub const COMMAND_BUFFER_INHERITANCE_INFO: Self = Self(41); + pub const COMMAND_BUFFER_BEGIN_INFO: Self = Self(42); + pub const RENDER_PASS_BEGIN_INFO: Self = Self(43); + pub const BUFFER_MEMORY_BARRIER: Self = Self(44); + pub const IMAGE_MEMORY_BARRIER: Self = Self(45); + pub const MEMORY_BARRIER: Self = Self(46); + #[doc = "Reserved for internal use by the loader, layers, and ICDs"] + pub const LOADER_INSTANCE_CREATE_INFO: Self = Self(47); + #[doc = "Reserved for internal use by the loader, layers, and ICDs"] + pub const LOADER_DEVICE_CREATE_INFO: Self = Self(48); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SubpassContents(pub(crate) i32); +impl SubpassContents { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SubpassContents { + pub const INLINE: Self = Self(0); + pub const SECONDARY_COMMAND_BUFFERS: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +#[must_use] +pub struct Result(pub(crate) i32); +impl Result { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl Result { + #[doc = "Command completed successfully"] + pub const SUCCESS: Self = Self(0); + #[doc = "A fence or query has not yet completed"] + pub const NOT_READY: Self = Self(1); + #[doc = "A wait operation has not completed in the specified time"] + pub const TIMEOUT: Self = Self(2); + #[doc = "An event is signaled"] + pub const EVENT_SET: Self = Self(3); + #[doc = "An event is unsignaled"] + pub const EVENT_RESET: Self = Self(4); + #[doc = "A return array was too small for the result"] + pub const INCOMPLETE: Self = Self(5); + #[doc = "A host memory allocation has failed"] + pub const ERROR_OUT_OF_HOST_MEMORY: Self = Self(-1); + #[doc = "A device memory allocation has failed"] + pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Self(-2); + #[doc = "Initialization of an object has failed"] + pub const ERROR_INITIALIZATION_FAILED: Self = Self(-3); + #[doc = "The logical device has been lost. See "] + pub const ERROR_DEVICE_LOST: Self = Self(-4); + #[doc = "Mapping of a memory object has failed"] + pub const ERROR_MEMORY_MAP_FAILED: Self = Self(-5); + #[doc = "Layer specified does not exist"] + pub const ERROR_LAYER_NOT_PRESENT: Self = Self(-6); + #[doc = "Extension specified does not exist"] + pub const ERROR_EXTENSION_NOT_PRESENT: Self = Self(-7); + #[doc = "Requested feature is not available on this device"] + pub const ERROR_FEATURE_NOT_PRESENT: Self = Self(-8); + #[doc = "Unable to find a Vulkan driver"] + pub const ERROR_INCOMPATIBLE_DRIVER: Self = Self(-9); + #[doc = "Too many objects of the type have already been created"] + pub const ERROR_TOO_MANY_OBJECTS: Self = Self(-10); + #[doc = "Requested format is not supported on this device"] + pub const ERROR_FORMAT_NOT_SUPPORTED: Self = Self(-11); + #[doc = "A requested pool allocation has failed due to fragmentation of the pool's memory"] + pub const ERROR_FRAGMENTED_POOL: Self = Self(-12); + #[doc = "An unknown error has occurred, due to an implementation or application bug"] + pub const ERROR_UNKNOWN: Self = Self(-13); +} +impl ::std::error::Error for Result {} +impl fmt::Display for Result { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match * self { Self :: SUCCESS => Some ("Command completed successfully") , Self :: NOT_READY => Some ("A fence or query has not yet completed") , Self :: TIMEOUT => Some ("A wait operation has not completed in the specified time") , Self :: EVENT_SET => Some ("An event is signaled") , Self :: EVENT_RESET => Some ("An event is unsignaled") , Self :: INCOMPLETE => Some ("A return array was too small for the result") , Self :: ERROR_OUT_OF_HOST_MEMORY => Some ("A host memory allocation has failed") , Self :: ERROR_OUT_OF_DEVICE_MEMORY => Some ("A device memory allocation has failed") , Self :: ERROR_INITIALIZATION_FAILED => Some ("Initialization of an object has failed") , Self :: ERROR_DEVICE_LOST => Some ("The logical device has been lost. See ") , Self :: ERROR_MEMORY_MAP_FAILED => Some ("Mapping of a memory object has failed") , Self :: ERROR_LAYER_NOT_PRESENT => Some ("Layer specified does not exist") , Self :: ERROR_EXTENSION_NOT_PRESENT => Some ("Extension specified does not exist") , Self :: ERROR_FEATURE_NOT_PRESENT => Some ("Requested feature is not available on this device") , Self :: ERROR_INCOMPATIBLE_DRIVER => Some ("Unable to find a Vulkan driver") , Self :: ERROR_TOO_MANY_OBJECTS => Some ("Too many objects of the type have already been created") , Self :: ERROR_FORMAT_NOT_SUPPORTED => Some ("Requested format is not supported on this device") , Self :: ERROR_FRAGMENTED_POOL => Some ("A requested pool allocation has failed due to fragmentation of the pool's memory") , Self :: ERROR_UNKNOWN => Some ("An unknown error has occurred, due to an implementation or application bug") , _ => None , } ; + if let Some(x) = name { + fmt.write_str(x) + } else { + ::fmt(self, fmt) + } + } +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DynamicState(pub(crate) i32); +impl DynamicState { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DynamicState { + pub const VIEWPORT: Self = Self(0); + pub const SCISSOR: Self = Self(1); + pub const LINE_WIDTH: Self = Self(2); + pub const DEPTH_BIAS: Self = Self(3); + pub const BLEND_CONSTANTS: Self = Self(4); + pub const DEPTH_BOUNDS: Self = Self(5); + pub const STENCIL_COMPARE_MASK: Self = Self(6); + pub const STENCIL_WRITE_MASK: Self = Self(7); + pub const STENCIL_REFERENCE: Self = Self(8); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DescriptorUpdateTemplateType(pub(crate) i32); +impl DescriptorUpdateTemplateType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DescriptorUpdateTemplateType { + #[doc = "Create descriptor update template for descriptor set updates"] + pub const DESCRIPTOR_SET: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ObjectType(pub(crate) i32); +impl ObjectType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ObjectType { + pub const UNKNOWN: Self = Self(0); + pub const INSTANCE: Self = Self(1); + pub const PHYSICAL_DEVICE: Self = Self(2); + pub const DEVICE: Self = Self(3); + pub const QUEUE: Self = Self(4); + pub const SEMAPHORE: Self = Self(5); + pub const COMMAND_BUFFER: Self = Self(6); + pub const FENCE: Self = Self(7); + pub const DEVICE_MEMORY: Self = Self(8); + pub const BUFFER: Self = Self(9); + pub const IMAGE: Self = Self(10); + pub const EVENT: Self = Self(11); + pub const QUERY_POOL: Self = Self(12); + pub const BUFFER_VIEW: Self = Self(13); + pub const IMAGE_VIEW: Self = Self(14); + pub const SHADER_MODULE: Self = Self(15); + pub const PIPELINE_CACHE: Self = Self(16); + pub const PIPELINE_LAYOUT: Self = Self(17); + pub const RENDER_PASS: Self = Self(18); + pub const PIPELINE: Self = Self(19); + pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20); + pub const SAMPLER: Self = Self(21); + pub const DESCRIPTOR_POOL: Self = Self(22); + pub const DESCRIPTOR_SET: Self = Self(23); + pub const FRAMEBUFFER: Self = Self(24); + pub const COMMAND_POOL: Self = Self(25); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct RayTracingInvocationReorderModeNV(pub(crate) i32); +impl RayTracingInvocationReorderModeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl RayTracingInvocationReorderModeNV { + pub const NONE: Self = Self(0); + pub const REORDER: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DirectDriverLoadingModeLUNARG(pub(crate) i32); +impl DirectDriverLoadingModeLUNARG { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DirectDriverLoadingModeLUNARG { + pub const EXCLUSIVE: Self = Self(0); + pub const INCLUSIVE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SemaphoreType(pub(crate) i32); +impl SemaphoreType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SemaphoreType { + pub const BINARY: Self = Self(0); + pub const TIMELINE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PresentModeKHR(pub(crate) i32); +impl PresentModeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PresentModeKHR { + pub const IMMEDIATE: Self = Self(0); + pub const MAILBOX: Self = Self(1); + pub const FIFO: Self = Self(2); + pub const FIFO_RELAXED: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ColorSpaceKHR(pub(crate) i32); +impl ColorSpaceKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ColorSpaceKHR { + pub const SRGB_NONLINEAR: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct TimeDomainEXT(pub(crate) i32); +impl TimeDomainEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl TimeDomainEXT { + pub const DEVICE: Self = Self(0); + pub const CLOCK_MONOTONIC: Self = Self(1); + pub const CLOCK_MONOTONIC_RAW: Self = Self(2); + pub const QUERY_PERFORMANCE_COUNTER: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DebugReportObjectTypeEXT(pub(crate) i32); +impl DebugReportObjectTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DebugReportObjectTypeEXT { + pub const UNKNOWN: Self = Self(0); + pub const INSTANCE: Self = Self(1); + pub const PHYSICAL_DEVICE: Self = Self(2); + pub const DEVICE: Self = Self(3); + pub const QUEUE: Self = Self(4); + pub const SEMAPHORE: Self = Self(5); + pub const COMMAND_BUFFER: Self = Self(6); + pub const FENCE: Self = Self(7); + pub const DEVICE_MEMORY: Self = Self(8); + pub const BUFFER: Self = Self(9); + pub const IMAGE: Self = Self(10); + pub const EVENT: Self = Self(11); + pub const QUERY_POOL: Self = Self(12); + pub const BUFFER_VIEW: Self = Self(13); + pub const IMAGE_VIEW: Self = Self(14); + pub const SHADER_MODULE: Self = Self(15); + pub const PIPELINE_CACHE: Self = Self(16); + pub const PIPELINE_LAYOUT: Self = Self(17); + pub const RENDER_PASS: Self = Self(18); + pub const PIPELINE: Self = Self(19); + pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20); + pub const SAMPLER: Self = Self(21); + pub const DESCRIPTOR_POOL: Self = Self(22); + pub const DESCRIPTOR_SET: Self = Self(23); + pub const FRAMEBUFFER: Self = Self(24); + pub const COMMAND_POOL: Self = Self(25); + pub const SURFACE_KHR: Self = Self(26); + pub const SWAPCHAIN_KHR: Self = Self(27); + pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(28); + pub const DISPLAY_KHR: Self = Self(29); + pub const DISPLAY_MODE_KHR: Self = Self(30); + pub const VALIDATION_CACHE_EXT: Self = Self(33); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceMemoryReportEventTypeEXT(pub(crate) i32); +impl DeviceMemoryReportEventTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceMemoryReportEventTypeEXT { + pub const ALLOCATE: Self = Self(0); + pub const FREE: Self = Self(1); + pub const IMPORT: Self = Self(2); + pub const UNIMPORT: Self = Self(3); + pub const ALLOCATION_FAILED: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct RasterizationOrderAMD(pub(crate) i32); +impl RasterizationOrderAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl RasterizationOrderAMD { + pub const STRICT: Self = Self(0); + pub const RELAXED: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ValidationCheckEXT(pub(crate) i32); +impl ValidationCheckEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ValidationCheckEXT { + pub const ALL: Self = Self(0); + pub const SHADERS: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ValidationFeatureEnableEXT(pub(crate) i32); +impl ValidationFeatureEnableEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ValidationFeatureEnableEXT { + pub const GPU_ASSISTED: Self = Self(0); + pub const GPU_ASSISTED_RESERVE_BINDING_SLOT: Self = Self(1); + pub const BEST_PRACTICES: Self = Self(2); + pub const DEBUG_PRINTF: Self = Self(3); + pub const SYNCHRONIZATION_VALIDATION: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ValidationFeatureDisableEXT(pub(crate) i32); +impl ValidationFeatureDisableEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ValidationFeatureDisableEXT { + pub const ALL: Self = Self(0); + pub const SHADERS: Self = Self(1); + pub const THREAD_SAFETY: Self = Self(2); + pub const API_PARAMETERS: Self = Self(3); + pub const OBJECT_LIFETIMES: Self = Self(4); + pub const CORE_CHECKS: Self = Self(5); + pub const UNIQUE_HANDLES: Self = Self(6); + pub const SHADER_VALIDATION_CACHE: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct IndirectCommandsTokenTypeNV(pub(crate) i32); +impl IndirectCommandsTokenTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl IndirectCommandsTokenTypeNV { + pub const SHADER_GROUP: Self = Self(0); + pub const STATE_FLAGS: Self = Self(1); + pub const INDEX_BUFFER: Self = Self(2); + pub const VERTEX_BUFFER: Self = Self(3); + pub const PUSH_CONSTANT: Self = Self(4); + pub const DRAW_INDEXED: Self = Self(5); + pub const DRAW: Self = Self(6); + pub const DRAW_TASKS: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DisplayPowerStateEXT(pub(crate) i32); +impl DisplayPowerStateEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DisplayPowerStateEXT { + pub const OFF: Self = Self(0); + pub const SUSPEND: Self = Self(1); + pub const ON: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceEventTypeEXT(pub(crate) i32); +impl DeviceEventTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceEventTypeEXT { + pub const DISPLAY_HOTPLUG: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DisplayEventTypeEXT(pub(crate) i32); +impl DisplayEventTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DisplayEventTypeEXT { + pub const FIRST_PIXEL_OUT: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ViewportCoordinateSwizzleNV(pub(crate) i32); +impl ViewportCoordinateSwizzleNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ViewportCoordinateSwizzleNV { + pub const POSITIVE_X: Self = Self(0); + pub const NEGATIVE_X: Self = Self(1); + pub const POSITIVE_Y: Self = Self(2); + pub const NEGATIVE_Y: Self = Self(3); + pub const POSITIVE_Z: Self = Self(4); + pub const NEGATIVE_Z: Self = Self(5); + pub const POSITIVE_W: Self = Self(6); + pub const NEGATIVE_W: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DiscardRectangleModeEXT(pub(crate) i32); +impl DiscardRectangleModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DiscardRectangleModeEXT { + pub const INCLUSIVE: Self = Self(0); + pub const EXCLUSIVE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PointClippingBehavior(pub(crate) i32); +impl PointClippingBehavior { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PointClippingBehavior { + pub const ALL_CLIP_PLANES: Self = Self(0); + pub const USER_CLIP_PLANES_ONLY: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerReductionMode(pub(crate) i32); +impl SamplerReductionMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerReductionMode { + pub const WEIGHTED_AVERAGE: Self = Self(0); + pub const MIN: Self = Self(1); + pub const MAX: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct TessellationDomainOrigin(pub(crate) i32); +impl TessellationDomainOrigin { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl TessellationDomainOrigin { + pub const UPPER_LEFT: Self = Self(0); + pub const LOWER_LEFT: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerYcbcrModelConversion(pub(crate) i32); +impl SamplerYcbcrModelConversion { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerYcbcrModelConversion { + pub const RGB_IDENTITY: Self = Self(0); + #[doc = "just range expansion"] + pub const YCBCR_IDENTITY: Self = Self(1); + #[doc = "aka HD YUV"] + pub const YCBCR_709: Self = Self(2); + #[doc = "aka SD YUV"] + pub const YCBCR_601: Self = Self(3); + #[doc = "aka UHD YUV"] + pub const YCBCR_2020: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerYcbcrRange(pub(crate) i32); +impl SamplerYcbcrRange { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerYcbcrRange { + #[doc = "Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped)"] + pub const ITU_FULL: Self = Self(0); + #[doc = "Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240"] + pub const ITU_NARROW: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ChromaLocation(pub(crate) i32); +impl ChromaLocation { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ChromaLocation { + pub const COSITED_EVEN: Self = Self(0); + pub const MIDPOINT: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BlendOverlapEXT(pub(crate) i32); +impl BlendOverlapEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BlendOverlapEXT { + pub const UNCORRELATED: Self = Self(0); + pub const DISJOINT: Self = Self(1); + pub const CONJOINT: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CoverageModulationModeNV(pub(crate) i32); +impl CoverageModulationModeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CoverageModulationModeNV { + pub const NONE: Self = Self(0); + pub const RGB: Self = Self(1); + pub const ALPHA: Self = Self(2); + pub const RGBA: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CoverageReductionModeNV(pub(crate) i32); +impl CoverageReductionModeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CoverageReductionModeNV { + pub const MERGE: Self = Self(0); + pub const TRUNCATE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32); +impl ValidationCacheHeaderVersionEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ValidationCacheHeaderVersionEXT { + pub const ONE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShaderInfoTypeAMD(pub(crate) i32); +impl ShaderInfoTypeAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShaderInfoTypeAMD { + pub const STATISTICS: Self = Self(0); + pub const BINARY: Self = Self(1); + pub const DISASSEMBLY: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct QueueGlobalPriorityKHR(pub(crate) i32); +impl QueueGlobalPriorityKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl QueueGlobalPriorityKHR { + pub const LOW: Self = Self(128); + pub const MEDIUM: Self = Self(256); + pub const HIGH: Self = Self(512); + pub const REALTIME: Self = Self(1_024); + pub const LOW_EXT: Self = Self::LOW; + pub const MEDIUM_EXT: Self = Self::MEDIUM; + pub const HIGH_EXT: Self = Self::HIGH; + pub const REALTIME_EXT: Self = Self::REALTIME; +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ConservativeRasterizationModeEXT(pub(crate) i32); +impl ConservativeRasterizationModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ConservativeRasterizationModeEXT { + pub const DISABLED: Self = Self(0); + pub const OVERESTIMATE: Self = Self(1); + pub const UNDERESTIMATE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VendorId(pub(crate) i32); +impl VendorId { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VendorId { + #[doc = "Vivante vendor ID"] + pub const VIV: Self = Self(0x1_0001); + #[doc = "VeriSilicon vendor ID"] + pub const VSI: Self = Self(0x1_0002); + #[doc = "Kazan Software Renderer"] + pub const KAZAN: Self = Self(0x1_0003); + #[doc = "Codeplay Software Ltd. vendor ID"] + pub const CODEPLAY: Self = Self(0x1_0004); + #[doc = "Mesa vendor ID"] + pub const MESA: Self = Self(0x1_0005); + #[doc = "PoCL vendor ID"] + pub const POCL: Self = Self(0x1_0006); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DriverId(pub(crate) i32); +impl DriverId { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DriverId { + #[doc = "Advanced Micro Devices, Inc."] + pub const AMD_PROPRIETARY: Self = Self(1); + #[doc = "Advanced Micro Devices, Inc."] + pub const AMD_OPEN_SOURCE: Self = Self(2); + #[doc = "Mesa open source project"] + pub const MESA_RADV: Self = Self(3); + #[doc = "NVIDIA Corporation"] + pub const NVIDIA_PROPRIETARY: Self = Self(4); + #[doc = "Intel Corporation"] + pub const INTEL_PROPRIETARY_WINDOWS: Self = Self(5); + #[doc = "Intel Corporation"] + pub const INTEL_OPEN_SOURCE_MESA: Self = Self(6); + #[doc = "Imagination Technologies"] + pub const IMAGINATION_PROPRIETARY: Self = Self(7); + #[doc = "Qualcomm Technologies, Inc."] + pub const QUALCOMM_PROPRIETARY: Self = Self(8); + #[doc = "Arm Limited"] + pub const ARM_PROPRIETARY: Self = Self(9); + #[doc = "Google LLC"] + pub const GOOGLE_SWIFTSHADER: Self = Self(10); + #[doc = "Google LLC"] + pub const GGP_PROPRIETARY: Self = Self(11); + #[doc = "Broadcom Inc."] + pub const BROADCOM_PROPRIETARY: Self = Self(12); + #[doc = "Mesa"] + pub const MESA_LLVMPIPE: Self = Self(13); + #[doc = "MoltenVK"] + pub const MOLTENVK: Self = Self(14); + #[doc = "Core Avionics & Industrial Inc."] + pub const COREAVI_PROPRIETARY: Self = Self(15); + #[doc = "Juice Technologies, Inc."] + pub const JUICE_PROPRIETARY: Self = Self(16); + #[doc = "Verisilicon, Inc."] + pub const VERISILICON_PROPRIETARY: Self = Self(17); + #[doc = "Mesa open source project"] + pub const MESA_TURNIP: Self = Self(18); + #[doc = "Mesa open source project"] + pub const MESA_V3DV: Self = Self(19); + #[doc = "Mesa open source project"] + pub const MESA_PANVK: Self = Self(20); + #[doc = "Samsung Electronics Co., Ltd."] + pub const SAMSUNG_PROPRIETARY: Self = Self(21); + #[doc = "Mesa open source project"] + pub const MESA_VENUS: Self = Self(22); + #[doc = "Mesa open source project"] + pub const MESA_DOZEN: Self = Self(23); + #[doc = "Mesa open source project"] + pub const MESA_NVK: Self = Self(24); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShadingRatePaletteEntryNV(pub(crate) i32); +impl ShadingRatePaletteEntryNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShadingRatePaletteEntryNV { + pub const NO_INVOCATIONS: Self = Self(0); + pub const TYPE_16_INVOCATIONS_PER_PIXEL: Self = Self(1); + pub const TYPE_8_INVOCATIONS_PER_PIXEL: Self = Self(2); + pub const TYPE_4_INVOCATIONS_PER_PIXEL: Self = Self(3); + pub const TYPE_2_INVOCATIONS_PER_PIXEL: Self = Self(4); + pub const TYPE_1_INVOCATION_PER_PIXEL: Self = Self(5); + pub const TYPE_1_INVOCATION_PER_2X1_PIXELS: Self = Self(6); + pub const TYPE_1_INVOCATION_PER_1X2_PIXELS: Self = Self(7); + pub const TYPE_1_INVOCATION_PER_2X2_PIXELS: Self = Self(8); + pub const TYPE_1_INVOCATION_PER_4X2_PIXELS: Self = Self(9); + pub const TYPE_1_INVOCATION_PER_2X4_PIXELS: Self = Self(10); + pub const TYPE_1_INVOCATION_PER_4X4_PIXELS: Self = Self(11); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CoarseSampleOrderTypeNV(pub(crate) i32); +impl CoarseSampleOrderTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CoarseSampleOrderTypeNV { + pub const DEFAULT: Self = Self(0); + pub const CUSTOM: Self = Self(1); + pub const PIXEL_MAJOR: Self = Self(2); + pub const SAMPLE_MAJOR: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CopyAccelerationStructureModeKHR(pub(crate) i32); +impl CopyAccelerationStructureModeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CopyAccelerationStructureModeKHR { + pub const CLONE: Self = Self(0); + pub const COMPACT: Self = Self(1); + pub const SERIALIZE: Self = Self(2); + pub const DESERIALIZE: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BuildAccelerationStructureModeKHR(pub(crate) i32); +impl BuildAccelerationStructureModeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BuildAccelerationStructureModeKHR { + pub const BUILD: Self = Self(0); + pub const UPDATE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureTypeKHR(pub(crate) i32); +impl AccelerationStructureTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureTypeKHR { + pub const TOP_LEVEL: Self = Self(0); + pub const BOTTOM_LEVEL: Self = Self(1); + pub const GENERIC: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct GeometryTypeKHR(pub(crate) i32); +impl GeometryTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl GeometryTypeKHR { + pub const TRIANGLES: Self = Self(0); + pub const AABBS: Self = Self(1); + pub const INSTANCES: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureMemoryRequirementsTypeNV(pub(crate) i32); +impl AccelerationStructureMemoryRequirementsTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureMemoryRequirementsTypeNV { + pub const OBJECT: Self = Self(0); + pub const BUILD_SCRATCH: Self = Self(1); + pub const UPDATE_SCRATCH: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureBuildTypeKHR(pub(crate) i32); +impl AccelerationStructureBuildTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureBuildTypeKHR { + pub const HOST: Self = Self(0); + pub const DEVICE: Self = Self(1); + pub const HOST_OR_DEVICE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct RayTracingShaderGroupTypeKHR(pub(crate) i32); +impl RayTracingShaderGroupTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl RayTracingShaderGroupTypeKHR { + pub const GENERAL: Self = Self(0); + pub const TRIANGLES_HIT_GROUP: Self = Self(1); + pub const PROCEDURAL_HIT_GROUP: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureCompatibilityKHR(pub(crate) i32); +impl AccelerationStructureCompatibilityKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureCompatibilityKHR { + pub const COMPATIBLE: Self = Self(0); + pub const INCOMPATIBLE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShaderGroupShaderKHR(pub(crate) i32); +impl ShaderGroupShaderKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShaderGroupShaderKHR { + pub const GENERAL: Self = Self(0); + pub const CLOSEST_HIT: Self = Self(1); + pub const ANY_HIT: Self = Self(2); + pub const INTERSECTION: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct MemoryOverallocationBehaviorAMD(pub(crate) i32); +impl MemoryOverallocationBehaviorAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl MemoryOverallocationBehaviorAMD { + pub const DEFAULT: Self = Self(0); + pub const ALLOWED: Self = Self(1); + pub const DISALLOWED: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ScopeNV(pub(crate) i32); +impl ScopeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ScopeNV { + pub const DEVICE: Self = Self(1); + pub const WORKGROUP: Self = Self(2); + pub const SUBGROUP: Self = Self(3); + pub const QUEUE_FAMILY: Self = Self(5); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ComponentTypeNV(pub(crate) i32); +impl ComponentTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ComponentTypeNV { + pub const FLOAT16: Self = Self(0); + pub const FLOAT32: Self = Self(1); + pub const FLOAT64: Self = Self(2); + pub const SINT8: Self = Self(3); + pub const SINT16: Self = Self(4); + pub const SINT32: Self = Self(5); + pub const SINT64: Self = Self(6); + pub const UINT8: Self = Self(7); + pub const UINT16: Self = Self(8); + pub const UINT32: Self = Self(9); + pub const UINT64: Self = Self(10); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FullScreenExclusiveEXT(pub(crate) i32); +impl FullScreenExclusiveEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FullScreenExclusiveEXT { + pub const DEFAULT: Self = Self(0); + pub const ALLOWED: Self = Self(1); + pub const DISALLOWED: Self = Self(2); + pub const APPLICATION_CONTROLLED: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceCounterScopeKHR(pub(crate) i32); +impl PerformanceCounterScopeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceCounterScopeKHR { + pub const COMMAND_BUFFER: Self = Self(0); + pub const RENDER_PASS: Self = Self(1); + pub const COMMAND: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceCounterUnitKHR(pub(crate) i32); +impl PerformanceCounterUnitKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceCounterUnitKHR { + pub const GENERIC: Self = Self(0); + pub const PERCENTAGE: Self = Self(1); + pub const NANOSECONDS: Self = Self(2); + pub const BYTES: Self = Self(3); + pub const BYTES_PER_SECOND: Self = Self(4); + pub const KELVIN: Self = Self(5); + pub const WATTS: Self = Self(6); + pub const VOLTS: Self = Self(7); + pub const AMPS: Self = Self(8); + pub const HERTZ: Self = Self(9); + pub const CYCLES: Self = Self(10); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceCounterStorageKHR(pub(crate) i32); +impl PerformanceCounterStorageKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceCounterStorageKHR { + pub const INT32: Self = Self(0); + pub const INT64: Self = Self(1); + pub const UINT32: Self = Self(2); + pub const UINT64: Self = Self(3); + pub const FLOAT32: Self = Self(4); + pub const FLOAT64: Self = Self(5); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceConfigurationTypeINTEL(pub(crate) i32); +impl PerformanceConfigurationTypeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceConfigurationTypeINTEL { + pub const COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct QueryPoolSamplingModeINTEL(pub(crate) i32); +impl QueryPoolSamplingModeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl QueryPoolSamplingModeINTEL { + pub const MANUAL: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceOverrideTypeINTEL(pub(crate) i32); +impl PerformanceOverrideTypeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceOverrideTypeINTEL { + pub const NULL_HARDWARE: Self = Self(0); + pub const FLUSH_GPU_CACHES: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceParameterTypeINTEL(pub(crate) i32); +impl PerformanceParameterTypeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceParameterTypeINTEL { + pub const HW_COUNTERS_SUPPORTED: Self = Self(0); + pub const STREAM_MARKER_VALIDS: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceValueTypeINTEL(pub(crate) i32); +impl PerformanceValueTypeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceValueTypeINTEL { + pub const UINT32: Self = Self(0); + pub const UINT64: Self = Self(1); + pub const FLOAT: Self = Self(2); + pub const BOOL: Self = Self(3); + pub const STRING: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShaderFloatControlsIndependence(pub(crate) i32); +impl ShaderFloatControlsIndependence { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShaderFloatControlsIndependence { + pub const TYPE_32_ONLY: Self = Self(0); + pub const ALL: Self = Self(1); + pub const NONE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineExecutableStatisticFormatKHR(pub(crate) i32); +impl PipelineExecutableStatisticFormatKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineExecutableStatisticFormatKHR { + pub const BOOL32: Self = Self(0); + pub const INT64: Self = Self(1); + pub const UINT64: Self = Self(2); + pub const FLOAT64: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct LineRasterizationModeEXT(pub(crate) i32); +impl LineRasterizationModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl LineRasterizationModeEXT { + pub const DEFAULT: Self = Self(0); + pub const RECTANGULAR: Self = Self(1); + pub const BRESENHAM: Self = Self(2); + pub const RECTANGULAR_SMOOTH: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateCombinerOpKHR(pub(crate) i32); +impl FragmentShadingRateCombinerOpKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateCombinerOpKHR { + pub const KEEP: Self = Self(0); + pub const REPLACE: Self = Self(1); + pub const MIN: Self = Self(2); + pub const MAX: Self = Self(3); + pub const MUL: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateNV(pub(crate) i32); +impl FragmentShadingRateNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateNV { + pub const TYPE_1_INVOCATION_PER_PIXEL: Self = Self(0); + pub const TYPE_1_INVOCATION_PER_1X2_PIXELS: Self = Self(1); + pub const TYPE_1_INVOCATION_PER_2X1_PIXELS: Self = Self(4); + pub const TYPE_1_INVOCATION_PER_2X2_PIXELS: Self = Self(5); + pub const TYPE_1_INVOCATION_PER_2X4_PIXELS: Self = Self(6); + pub const TYPE_1_INVOCATION_PER_4X2_PIXELS: Self = Self(9); + pub const TYPE_1_INVOCATION_PER_4X4_PIXELS: Self = Self(10); + pub const TYPE_2_INVOCATIONS_PER_PIXEL: Self = Self(11); + pub const TYPE_4_INVOCATIONS_PER_PIXEL: Self = Self(12); + pub const TYPE_8_INVOCATIONS_PER_PIXEL: Self = Self(13); + pub const TYPE_16_INVOCATIONS_PER_PIXEL: Self = Self(14); + pub const NO_INVOCATIONS: Self = Self(15); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateTypeNV(pub(crate) i32); +impl FragmentShadingRateTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateTypeNV { + pub const FRAGMENT_SIZE: Self = Self(0); + pub const ENUMS: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SubpassMergeStatusEXT(pub(crate) i32); +impl SubpassMergeStatusEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SubpassMergeStatusEXT { + pub const MERGED: Self = Self(0); + pub const DISALLOWED: Self = Self(1); + pub const NOT_MERGED_SIDE_EFFECTS: Self = Self(2); + pub const NOT_MERGED_SAMPLES_MISMATCH: Self = Self(3); + pub const NOT_MERGED_VIEWS_MISMATCH: Self = Self(4); + pub const NOT_MERGED_ALIASING: Self = Self(5); + pub const NOT_MERGED_DEPENDENCIES: Self = Self(6); + pub const NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT: Self = Self(7); + pub const NOT_MERGED_TOO_MANY_ATTACHMENTS: Self = Self(8); + pub const NOT_MERGED_INSUFFICIENT_STORAGE: Self = Self(9); + pub const NOT_MERGED_DEPTH_STENCIL_COUNT: Self = Self(10); + pub const NOT_MERGED_RESOLVE_ATTACHMENT_REUSE: Self = Self(11); + pub const NOT_MERGED_SINGLE_SUBPASS: Self = Self(12); + pub const NOT_MERGED_UNSPECIFIED: Self = Self(13); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ProvokingVertexModeEXT(pub(crate) i32); +impl ProvokingVertexModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ProvokingVertexModeEXT { + pub const FIRST_VERTEX: Self = Self(0); + pub const LAST_VERTEX: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureMotionInstanceTypeNV(pub(crate) i32); +impl AccelerationStructureMotionInstanceTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureMotionInstanceTypeNV { + pub const STATIC: Self = Self(0); + pub const MATRIX_MOTION: Self = Self(1); + pub const SRT_MOTION: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceAddressBindingTypeEXT(pub(crate) i32); +impl DeviceAddressBindingTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceAddressBindingTypeEXT { + pub const BIND: Self = Self(0); + pub const UNBIND: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct QueryResultStatusKHR(pub(crate) i32); +impl QueryResultStatusKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl QueryResultStatusKHR { + pub const ERROR: Self = Self(-1); + pub const NOT_READY: Self = Self(0); + pub const COMPLETE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VideoEncodeTuningModeKHR(pub(crate) i32); +impl VideoEncodeTuningModeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VideoEncodeTuningModeKHR { + pub const DEFAULT: Self = Self(0); + pub const HIGH_QUALITY: Self = Self(1); + pub const LOW_LATENCY: Self = Self(2); + pub const ULTRA_LOW_LATENCY: Self = Self(3); + pub const LOSSLESS: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VideoEncodeH264RateControlStructureEXT(pub(crate) i32); +impl VideoEncodeH264RateControlStructureEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VideoEncodeH264RateControlStructureEXT { + pub const UNKNOWN: Self = Self(0); + pub const FLAT: Self = Self(1); + pub const DYADIC: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VideoEncodeH265RateControlStructureEXT(pub(crate) i32); +impl VideoEncodeH265RateControlStructureEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VideoEncodeH265RateControlStructureEXT { + pub const UNKNOWN: Self = Self(0); + pub const FLAT: Self = Self(1); + pub const DYADIC: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineRobustnessBufferBehaviorEXT(pub(crate) i32); +impl PipelineRobustnessBufferBehaviorEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineRobustnessBufferBehaviorEXT { + pub const DEVICE_DEFAULT: Self = Self(0); + pub const DISABLED: Self = Self(1); + pub const ROBUST_BUFFER_ACCESS: Self = Self(2); + pub const ROBUST_BUFFER_ACCESS_2: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineRobustnessImageBehaviorEXT(pub(crate) i32); +impl PipelineRobustnessImageBehaviorEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineRobustnessImageBehaviorEXT { + pub const DEVICE_DEFAULT: Self = Self(0); + pub const DISABLED: Self = Self(1); + pub const ROBUST_IMAGE_ACCESS: Self = Self(2); + pub const ROBUST_IMAGE_ACCESS_2: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpticalFlowPerformanceLevelNV(pub(crate) i32); +impl OpticalFlowPerformanceLevelNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpticalFlowPerformanceLevelNV { + pub const UNKNOWN: Self = Self(0); + pub const SLOW: Self = Self(1); + pub const MEDIUM: Self = Self(2); + pub const FAST: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpticalFlowSessionBindingPointNV(pub(crate) i32); +impl OpticalFlowSessionBindingPointNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpticalFlowSessionBindingPointNV { + pub const UNKNOWN: Self = Self(0); + pub const INPUT: Self = Self(1); + pub const REFERENCE: Self = Self(2); + pub const HINT: Self = Self(3); + pub const FLOW_VECTOR: Self = Self(4); + pub const BACKWARD_FLOW_VECTOR: Self = Self(5); + pub const COST: Self = Self(6); + pub const BACKWARD_COST: Self = Self(7); + pub const GLOBAL_FLOW: Self = Self(8); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct MicromapTypeEXT(pub(crate) i32); +impl MicromapTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl MicromapTypeEXT { + pub const OPACITY_MICROMAP: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CopyMicromapModeEXT(pub(crate) i32); +impl CopyMicromapModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CopyMicromapModeEXT { + pub const CLONE: Self = Self(0); + pub const SERIALIZE: Self = Self(1); + pub const DESERIALIZE: Self = Self(2); + pub const COMPACT: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BuildMicromapModeEXT(pub(crate) i32); +impl BuildMicromapModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BuildMicromapModeEXT { + pub const BUILD: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpacityMicromapFormatEXT(pub(crate) i32); +impl OpacityMicromapFormatEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpacityMicromapFormatEXT { + pub const TYPE_2_STATE: Self = Self(1); + pub const TYPE_4_STATE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpacityMicromapSpecialIndexEXT(pub(crate) i32); +impl OpacityMicromapSpecialIndexEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpacityMicromapSpecialIndexEXT { + pub const FULLY_TRANSPARENT: Self = Self(-1); + pub const FULLY_OPAQUE: Self = Self(-2); + pub const FULLY_UNKNOWN_TRANSPARENT: Self = Self(-3); + pub const FULLY_UNKNOWN_OPAQUE: Self = Self(-4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceFaultAddressTypeEXT(pub(crate) i32); +impl DeviceFaultAddressTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceFaultAddressTypeEXT { + #[doc = "Currently unused"] + pub const NONE: Self = Self(0); + pub const READ_INVALID: Self = Self(1); + pub const WRITE_INVALID: Self = Self(2); + pub const EXECUTE_INVALID: Self = Self(3); + pub const INSTRUCTION_POINTER_UNKNOWN: Self = Self(4); + pub const INSTRUCTION_POINTER_INVALID: Self = Self(5); + pub const INSTRUCTION_POINTER_FAULT: Self = Self(6); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceFaultVendorBinaryHeaderVersionEXT(pub(crate) i32); +impl DeviceFaultVendorBinaryHeaderVersionEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceFaultVendorBinaryHeaderVersionEXT { + pub const ONE: Self = Self(1); +} +impl fmt::Debug for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::VIDEO_SESSION_KHR => Some("VIDEO_SESSION_KHR"), + Self::VIDEO_SESSION_PARAMETERS_KHR => Some("VIDEO_SESSION_PARAMETERS_KHR"), + Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"), + Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::PERFORMANCE_CONFIGURATION_INTEL => Some("PERFORMANCE_CONFIGURATION_INTEL"), + Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"), + Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"), + Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), + Self::MICROMAP_EXT => Some("MICROMAP_EXT"), + Self::OPTICAL_FLOW_SESSION_NV => Some("OPTICAL_FLOW_SESSION_NV"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::PRIVATE_DATA_SLOT => Some("PRIVATE_DATA_SLOT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for Result { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SUCCESS => Some("SUCCESS"), + Self::NOT_READY => Some("NOT_READY"), + Self::TIMEOUT => Some("TIMEOUT"), + Self::EVENT_SET => Some("EVENT_SET"), + Self::EVENT_RESET => Some("EVENT_RESET"), + Self::INCOMPLETE => Some("INCOMPLETE"), + Self::ERROR_OUT_OF_HOST_MEMORY => Some("ERROR_OUT_OF_HOST_MEMORY"), + Self::ERROR_OUT_OF_DEVICE_MEMORY => Some("ERROR_OUT_OF_DEVICE_MEMORY"), + Self::ERROR_INITIALIZATION_FAILED => Some("ERROR_INITIALIZATION_FAILED"), + Self::ERROR_DEVICE_LOST => Some("ERROR_DEVICE_LOST"), + Self::ERROR_MEMORY_MAP_FAILED => Some("ERROR_MEMORY_MAP_FAILED"), + Self::ERROR_LAYER_NOT_PRESENT => Some("ERROR_LAYER_NOT_PRESENT"), + Self::ERROR_EXTENSION_NOT_PRESENT => Some("ERROR_EXTENSION_NOT_PRESENT"), + Self::ERROR_FEATURE_NOT_PRESENT => Some("ERROR_FEATURE_NOT_PRESENT"), + Self::ERROR_INCOMPATIBLE_DRIVER => Some("ERROR_INCOMPATIBLE_DRIVER"), + Self::ERROR_TOO_MANY_OBJECTS => Some("ERROR_TOO_MANY_OBJECTS"), + Self::ERROR_FORMAT_NOT_SUPPORTED => Some("ERROR_FORMAT_NOT_SUPPORTED"), + Self::ERROR_FRAGMENTED_POOL => Some("ERROR_FRAGMENTED_POOL"), + Self::ERROR_UNKNOWN => Some("ERROR_UNKNOWN"), + Self::ERROR_SURFACE_LOST_KHR => Some("ERROR_SURFACE_LOST_KHR"), + Self::ERROR_NATIVE_WINDOW_IN_USE_KHR => Some("ERROR_NATIVE_WINDOW_IN_USE_KHR"), + Self::SUBOPTIMAL_KHR => Some("SUBOPTIMAL_KHR"), + Self::ERROR_OUT_OF_DATE_KHR => Some("ERROR_OUT_OF_DATE_KHR"), + Self::ERROR_INCOMPATIBLE_DISPLAY_KHR => Some("ERROR_INCOMPATIBLE_DISPLAY_KHR"), + Self::ERROR_VALIDATION_FAILED_EXT => Some("ERROR_VALIDATION_FAILED_EXT"), + Self::ERROR_INVALID_SHADER_NV => Some("ERROR_INVALID_SHADER_NV"), + Self::ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR => { + Some("ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR") + } + Self::ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT => { + Some("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT") + } + Self::ERROR_NOT_PERMITTED_KHR => Some("ERROR_NOT_PERMITTED_KHR"), + Self::ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT => { + Some("ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT") + } + Self::THREAD_IDLE_KHR => Some("THREAD_IDLE_KHR"), + Self::THREAD_DONE_KHR => Some("THREAD_DONE_KHR"), + Self::OPERATION_DEFERRED_KHR => Some("OPERATION_DEFERRED_KHR"), + Self::OPERATION_NOT_DEFERRED_KHR => Some("OPERATION_NOT_DEFERRED_KHR"), + Self::ERROR_COMPRESSION_EXHAUSTED_EXT => Some("ERROR_COMPRESSION_EXHAUSTED_EXT"), + Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"), + Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"), + Self::ERROR_FRAGMENTATION => Some("ERROR_FRAGMENTATION"), + Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS => { + Some("ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS") + } + Self::PIPELINE_COMPILE_REQUIRED => Some("PIPELINE_COMPILE_REQUIRED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} diff --git a/third_party/rust/ash/src/vk/extensions.rs b/third_party/rust/ash/src/vk/extensions.rs new file mode 100644 index 0000000000..cf4936d995 --- /dev/null +++ b/third_party/rust/ash/src/vk/extensions.rs @@ -0,0 +1,25322 @@ +use crate::vk::aliases::*; +use crate::vk::bitflags::*; +use crate::vk::definitions::*; +use crate::vk::enums::*; +use crate::vk::platform_types::*; +use std::os::raw::*; +impl KhrSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_surface\0") } + } + pub const SPEC_VERSION: u32 = 25u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySurfaceKHR = unsafe extern "system" fn( + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + surface: SurfaceKHR, + p_supported: *mut Bool32, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *mut SurfaceCapabilitiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_format_count: *mut u32, + p_surface_formats: *mut SurfaceFormatKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_present_mode_count: *mut u32, + p_present_modes: *mut PresentModeKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrSurfaceFn { + pub destroy_surface_khr: PFN_vkDestroySurfaceKHR, + pub get_physical_device_surface_support_khr: PFN_vkGetPhysicalDeviceSurfaceSupportKHR, + pub get_physical_device_surface_capabilities_khr: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, + pub get_physical_device_surface_formats_khr: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR, + pub get_physical_device_surface_present_modes_khr: + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR, +} +unsafe impl Send for KhrSurfaceFn {} +unsafe impl Sync for KhrSurfaceFn {} +impl KhrSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + destroy_surface_khr: unsafe { + unsafe extern "system" fn destroy_surface_khr( + _instance: Instance, + _surface: SurfaceKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_surface_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + destroy_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _surface: SurfaceKHR, + _p_supported: *mut Bool32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_support_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_capabilities_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_capabilities_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_capabilities: *mut SurfaceCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_formats_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_formats_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_format_count: *mut u32, + _p_surface_formats: *mut SurfaceFormatKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_formats_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceFormatsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_formats_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_present_modes_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_present_modes_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_present_mode_count: *mut u32, + _p_present_modes: *mut PresentModeKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_present_modes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfacePresentModesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_present_modes_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_surface'"] +impl ObjectType { + pub const SURFACE_KHR: Self = Self(1_000_000_000); +} +#[doc = "Generated from 'VK_KHR_surface'"] +impl Result { + pub const ERROR_SURFACE_LOST_KHR: Self = Self(-1_000_000_000); + pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Self(-1_000_000_001); +} +impl KhrSwapchainFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain\0") } + } + pub const SPEC_VERSION: u32 = 70u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSwapchainKHR = unsafe extern "system" fn( + device: Device, + p_create_info: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchain: *mut SwapchainKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySwapchainKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainImagesKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_swapchain_image_count: *mut u32, + p_swapchain_images: *mut Image, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireNextImageKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + timeout: u64, + semaphore: Semaphore, + fence: Fence, + p_image_index: *mut u32, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueuePresentKHR = + unsafe extern "system" fn(queue: Queue, p_present_info: *const PresentInfoKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHR = unsafe extern "system" fn( + device: Device, + p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupSurfacePresentModesKHR = unsafe extern "system" fn( + device: Device, + surface: SurfaceKHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDevicePresentRectanglesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_rect_count: *mut u32, + p_rects: *mut Rect2D, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireNextImage2KHR = unsafe extern "system" fn( + device: Device, + p_acquire_info: *const AcquireNextImageInfoKHR, + p_image_index: *mut u32, +) -> Result; +#[derive(Clone)] +pub struct KhrSwapchainFn { + pub create_swapchain_khr: PFN_vkCreateSwapchainKHR, + pub destroy_swapchain_khr: PFN_vkDestroySwapchainKHR, + pub get_swapchain_images_khr: PFN_vkGetSwapchainImagesKHR, + pub acquire_next_image_khr: PFN_vkAcquireNextImageKHR, + pub queue_present_khr: PFN_vkQueuePresentKHR, + pub get_device_group_present_capabilities_khr: PFN_vkGetDeviceGroupPresentCapabilitiesKHR, + pub get_device_group_surface_present_modes_khr: PFN_vkGetDeviceGroupSurfacePresentModesKHR, + pub get_physical_device_present_rectangles_khr: PFN_vkGetPhysicalDevicePresentRectanglesKHR, + pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR, +} +unsafe impl Send for KhrSwapchainFn {} +unsafe impl Sync for KhrSwapchainFn {} +impl KhrSwapchainFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_swapchain_khr: unsafe { + unsafe extern "system" fn create_swapchain_khr( + _device: Device, + _p_create_info: *const SwapchainCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_swapchain: *mut SwapchainKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_swapchain_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSwapchainKHR\0"); + let val = _f(cname); + if val.is_null() { + create_swapchain_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_swapchain_khr: unsafe { + unsafe extern "system" fn destroy_swapchain_khr( + _device: Device, + _swapchain: SwapchainKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_swapchain_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySwapchainKHR\0"); + let val = _f(cname); + if val.is_null() { + destroy_swapchain_khr + } else { + ::std::mem::transmute(val) + } + }, + get_swapchain_images_khr: unsafe { + unsafe extern "system" fn get_swapchain_images_khr( + _device: Device, + _swapchain: SwapchainKHR, + _p_swapchain_image_count: *mut u32, + _p_swapchain_images: *mut Image, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_images_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainImagesKHR\0"); + let val = _f(cname); + if val.is_null() { + get_swapchain_images_khr + } else { + ::std::mem::transmute(val) + } + }, + acquire_next_image_khr: unsafe { + unsafe extern "system" fn acquire_next_image_khr( + _device: Device, + _swapchain: SwapchainKHR, + _timeout: u64, + _semaphore: Semaphore, + _fence: Fence, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImageKHR\0"); + let val = _f(cname); + if val.is_null() { + acquire_next_image_khr + } else { + ::std::mem::transmute(val) + } + }, + queue_present_khr: unsafe { + unsafe extern "system" fn queue_present_khr( + _queue: Queue, + _p_present_info: *const PresentInfoKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_present_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueuePresentKHR\0"); + let val = _f(cname); + if val.is_null() { + queue_present_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_present_capabilities_khr: unsafe { + unsafe extern "system" fn get_device_group_present_capabilities_khr( + _device: Device, + _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_present_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupPresentCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_present_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_surface_present_modes_khr: unsafe { + unsafe extern "system" fn get_device_group_surface_present_modes_khr( + _device: Device, + _surface: SurfaceKHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupSurfacePresentModesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_surface_present_modes_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_present_rectangles_khr: unsafe { + unsafe extern "system" fn get_physical_device_present_rectangles_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_rect_count: *mut u32, + _p_rects: *mut Rect2D, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_present_rectangles_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDevicePresentRectanglesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_present_rectangles_khr + } else { + ::std::mem::transmute(val) + } + }, + acquire_next_image2_khr: unsafe { + unsafe extern "system" fn acquire_next_image2_khr( + _device: Device, + _p_acquire_info: *const AcquireNextImageInfoKHR, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + acquire_next_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl ImageLayout { + pub const PRESENT_SRC_KHR: Self = Self(1_000_001_002); +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl ObjectType { + pub const SWAPCHAIN_KHR: Self = Self(1_000_001_000); +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl Result { + pub const SUBOPTIMAL_KHR: Self = Self(1_000_001_003); + pub const ERROR_OUT_OF_DATE_KHR: Self = Self(-1_000_001_004); +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl StructureType { + pub const SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_001_000); + pub const PRESENT_INFO_KHR: Self = Self(1_000_001_001); + pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = Self(1_000_060_007); + pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_008); + pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = Self(1_000_060_009); + pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = Self(1_000_060_010); + pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = Self(1_000_060_011); + pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_012); +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl SwapchainCreateFlagsKHR { + #[doc = "Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"] + pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b1); + #[doc = "Swapchain is protected"] + pub const PROTECTED: Self = Self(0b10); +} +impl KhrDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display\0") } + } + pub const SPEC_VERSION: u32 = 23u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPlanePropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + plane_index: u32, + p_display_count: *mut u32, + p_displays: *mut DisplayKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayModePropertiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *mut u32, + p_properties: *mut DisplayModePropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDisplayModeKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *mut DisplayModeKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + mode: DisplayModeKHR, + plane_index: u32, + p_capabilities: *mut DisplayPlaneCapabilitiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDisplayPlaneSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const DisplaySurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrDisplayFn { + pub get_physical_device_display_properties_khr: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR, + pub get_physical_device_display_plane_properties_khr: + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, + pub get_display_plane_supported_displays_khr: PFN_vkGetDisplayPlaneSupportedDisplaysKHR, + pub get_display_mode_properties_khr: PFN_vkGetDisplayModePropertiesKHR, + pub create_display_mode_khr: PFN_vkCreateDisplayModeKHR, + pub get_display_plane_capabilities_khr: PFN_vkGetDisplayPlaneCapabilitiesKHR, + pub create_display_plane_surface_khr: PFN_vkCreateDisplayPlaneSurfaceKHR, +} +unsafe impl Send for KhrDisplayFn {} +unsafe impl Sync for KhrDisplayFn {} +impl KhrDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_display_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_display_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDisplayPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_display_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_display_plane_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_display_plane_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPlanePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_plane_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDisplayPlanePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_display_plane_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_plane_supported_displays_khr: unsafe { + unsafe extern "system" fn get_display_plane_supported_displays_khr( + _physical_device: PhysicalDevice, + _plane_index: u32, + _p_display_count: *mut u32, + _p_displays: *mut DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_supported_displays_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayPlaneSupportedDisplaysKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_plane_supported_displays_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_mode_properties_khr: unsafe { + unsafe extern "system" fn get_display_mode_properties_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_property_count: *mut u32, + _p_properties: *mut DisplayModePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_mode_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayModePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_mode_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + create_display_mode_khr: unsafe { + unsafe extern "system" fn create_display_mode_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_create_info: *const DisplayModeCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_mode: *mut DisplayModeKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_display_mode_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDisplayModeKHR\0"); + let val = _f(cname); + if val.is_null() { + create_display_mode_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_plane_capabilities_khr: unsafe { + unsafe extern "system" fn get_display_plane_capabilities_khr( + _physical_device: PhysicalDevice, + _mode: DisplayModeKHR, + _plane_index: u32, + _p_capabilities: *mut DisplayPlaneCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayPlaneCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_plane_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + create_display_plane_surface_khr: unsafe { + unsafe extern "system" fn create_display_plane_surface_khr( + _instance: Instance, + _p_create_info: *const DisplaySurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_display_plane_surface_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDisplayPlaneSurfaceKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_display_plane_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_display'"] +impl ObjectType { + pub const DISPLAY_KHR: Self = Self(1_000_002_000); + pub const DISPLAY_MODE_KHR: Self = Self(1_000_002_001); +} +#[doc = "Generated from 'VK_KHR_display'"] +impl StructureType { + pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = Self(1_000_002_000); + pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_002_001); +} +impl KhrDisplaySwapchainFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display_swapchain\0") } + } + pub const SPEC_VERSION: u32 = 10u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSharedSwapchainsKHR = unsafe extern "system" fn( + device: Device, + swapchain_count: u32, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *mut SwapchainKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrDisplaySwapchainFn { + pub create_shared_swapchains_khr: PFN_vkCreateSharedSwapchainsKHR, +} +unsafe impl Send for KhrDisplaySwapchainFn {} +unsafe impl Sync for KhrDisplaySwapchainFn {} +impl KhrDisplaySwapchainFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_shared_swapchains_khr: unsafe { + unsafe extern "system" fn create_shared_swapchains_khr( + _device: Device, + _swapchain_count: u32, + _p_create_infos: *const SwapchainCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_swapchains: *mut SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_shared_swapchains_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateSharedSwapchainsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_shared_swapchains_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_display_swapchain'"] +impl Result { + pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Self(-1_000_003_001); +} +#[doc = "Generated from 'VK_KHR_display_swapchain'"] +impl StructureType { + pub const DISPLAY_PRESENT_INFO_KHR: Self = Self(1_000_003_000); +} +impl KhrXlibSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xlib_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateXlibSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + dpy: *mut Display, + visual_id: VisualID, +) -> Bool32; +#[derive(Clone)] +pub struct KhrXlibSurfaceFn { + pub create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR, + pub get_physical_device_xlib_presentation_support_khr: + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR, +} +unsafe impl Send for KhrXlibSurfaceFn {} +unsafe impl Sync for KhrXlibSurfaceFn {} +impl KhrXlibSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_xlib_surface_khr: unsafe { + unsafe extern "system" fn create_xlib_surface_khr( + _instance: Instance, + _p_create_info: *const XlibSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_xlib_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateXlibSurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_xlib_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_xlib_presentation_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_xlib_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _dpy: *mut Display, + _visual_id: VisualID, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_xlib_presentation_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceXlibPresentationSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_xlib_presentation_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_xlib_surface'"] +impl StructureType { + pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_004_000); +} +impl KhrXcbSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xcb_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateXcbSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + connection: *mut xcb_connection_t, + visual_id: xcb_visualid_t, +) -> Bool32; +#[derive(Clone)] +pub struct KhrXcbSurfaceFn { + pub create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR, + pub get_physical_device_xcb_presentation_support_khr: + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR, +} +unsafe impl Send for KhrXcbSurfaceFn {} +unsafe impl Sync for KhrXcbSurfaceFn {} +impl KhrXcbSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_xcb_surface_khr: unsafe { + unsafe extern "system" fn create_xcb_surface_khr( + _instance: Instance, + _p_create_info: *const XcbSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_xcb_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateXcbSurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_xcb_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_xcb_presentation_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_xcb_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _connection: *mut xcb_connection_t, + _visual_id: xcb_visualid_t, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_xcb_presentation_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceXcbPresentationSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_xcb_presentation_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_xcb_surface'"] +impl StructureType { + pub const XCB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_005_000); +} +impl KhrWaylandSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_wayland_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateWaylandSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const WaylandSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + display: *mut wl_display, +) + -> Bool32; +#[derive(Clone)] +pub struct KhrWaylandSurfaceFn { + pub create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR, + pub get_physical_device_wayland_presentation_support_khr: + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR, +} +unsafe impl Send for KhrWaylandSurfaceFn {} +unsafe impl Sync for KhrWaylandSurfaceFn {} +impl KhrWaylandSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_wayland_surface_khr: unsafe { + unsafe extern "system" fn create_wayland_surface_khr( + _instance: Instance, + _p_create_info: *const WaylandSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_wayland_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateWaylandSurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_wayland_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_wayland_presentation_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_wayland_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _display: *mut wl_display, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_wayland_presentation_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceWaylandPresentationSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_wayland_presentation_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_wayland_surface'"] +impl StructureType { + pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_006_000); +} +impl KhrMirSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_mir_surface\0") } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[derive(Clone)] +pub struct KhrMirSurfaceFn {} +unsafe impl Send for KhrMirSurfaceFn {} +unsafe impl Sync for KhrMirSurfaceFn {} +impl KhrMirSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrAndroidSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_android_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateAndroidSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const AndroidSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrAndroidSurfaceFn { + pub create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR, +} +unsafe impl Send for KhrAndroidSurfaceFn {} +unsafe impl Sync for KhrAndroidSurfaceFn {} +impl KhrAndroidSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_android_surface_khr: unsafe { + unsafe extern "system" fn create_android_surface_khr( + _instance: Instance, + _p_create_info: *const AndroidSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_android_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateAndroidSurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_android_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_android_surface'"] +impl StructureType { + pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_008_000); +} +impl KhrWin32SurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateWin32SurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = + unsafe extern "system" fn(physical_device: PhysicalDevice, queue_family_index: u32) -> Bool32; +#[derive(Clone)] +pub struct KhrWin32SurfaceFn { + pub create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR, + pub get_physical_device_win32_presentation_support_khr: + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR, +} +unsafe impl Send for KhrWin32SurfaceFn {} +unsafe impl Sync for KhrWin32SurfaceFn {} +impl KhrWin32SurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_win32_surface_khr: unsafe { + unsafe extern "system" fn create_win32_surface_khr( + _instance: Instance, + _p_create_info: *const Win32SurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_win32_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateWin32SurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_win32_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_win32_presentation_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_win32_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_win32_presentation_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceWin32PresentationSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_win32_presentation_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_win32_surface'"] +impl StructureType { + pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_009_000); +} +impl AndroidNativeBufferFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_native_buffer\0") } + } + pub const SPEC_VERSION: u32 = 8u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainGrallocUsageANDROID = unsafe extern "system" fn( + device: Device, + format: Format, + image_usage: ImageUsageFlags, + gralloc_usage: *mut c_int, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireImageANDROID = unsafe extern "system" fn( + device: Device, + image: Image, + native_fence_fd: c_int, + semaphore: Semaphore, + fence: Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSignalReleaseImageANDROID = unsafe extern "system" fn( + queue: Queue, + wait_semaphore_count: u32, + p_wait_semaphores: *const Semaphore, + image: Image, + p_native_fence_fd: *mut c_int, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainGrallocUsage2ANDROID = unsafe extern "system" fn( + device: Device, + format: Format, + image_usage: ImageUsageFlags, + swapchain_image_usage: SwapchainImageUsageFlagsANDROID, + gralloc_consumer_usage: *mut u64, + gralloc_producer_usage: *mut u64, +) -> Result; +#[derive(Clone)] +pub struct AndroidNativeBufferFn { + pub get_swapchain_gralloc_usage_android: PFN_vkGetSwapchainGrallocUsageANDROID, + pub acquire_image_android: PFN_vkAcquireImageANDROID, + pub queue_signal_release_image_android: PFN_vkQueueSignalReleaseImageANDROID, + pub get_swapchain_gralloc_usage2_android: PFN_vkGetSwapchainGrallocUsage2ANDROID, +} +unsafe impl Send for AndroidNativeBufferFn {} +unsafe impl Sync for AndroidNativeBufferFn {} +impl AndroidNativeBufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_swapchain_gralloc_usage_android: unsafe { + unsafe extern "system" fn get_swapchain_gralloc_usage_android( + _device: Device, + _format: Format, + _image_usage: ImageUsageFlags, + _gralloc_usage: *mut c_int, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_gralloc_usage_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSwapchainGrallocUsageANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + get_swapchain_gralloc_usage_android + } else { + ::std::mem::transmute(val) + } + }, + acquire_image_android: unsafe { + unsafe extern "system" fn acquire_image_android( + _device: Device, + _image: Image, + _native_fence_fd: c_int, + _semaphore: Semaphore, + _fence: Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_image_android) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireImageANDROID\0"); + let val = _f(cname); + if val.is_null() { + acquire_image_android + } else { + ::std::mem::transmute(val) + } + }, + queue_signal_release_image_android: unsafe { + unsafe extern "system" fn queue_signal_release_image_android( + _queue: Queue, + _wait_semaphore_count: u32, + _p_wait_semaphores: *const Semaphore, + _image: Image, + _p_native_fence_fd: *mut c_int, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(queue_signal_release_image_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueSignalReleaseImageANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + queue_signal_release_image_android + } else { + ::std::mem::transmute(val) + } + }, + get_swapchain_gralloc_usage2_android: unsafe { + unsafe extern "system" fn get_swapchain_gralloc_usage2_android( + _device: Device, + _format: Format, + _image_usage: ImageUsageFlags, + _swapchain_image_usage: SwapchainImageUsageFlagsANDROID, + _gralloc_consumer_usage: *mut u64, + _gralloc_producer_usage: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_gralloc_usage2_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSwapchainGrallocUsage2ANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + get_swapchain_gralloc_usage2_android + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_ANDROID_native_buffer'"] +impl StructureType { + pub const NATIVE_BUFFER_ANDROID: Self = Self(1_000_010_000); + pub const SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID: Self = Self(1_000_010_001); + pub const PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID: Self = Self(1_000_010_002); +} +impl ExtDebugReportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_report\0") } + } + pub const SPEC_VERSION: u32 = 10u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const DebugReportCallbackCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_callback: *mut DebugReportCallbackEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDebugReportCallbackEXT = unsafe extern "system" fn( + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkDebugReportMessageEXT = unsafe extern "system" fn( + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: u64, + location: usize, + message_code: i32, + p_layer_prefix: *const c_char, + p_message: *const c_char, +); +#[derive(Clone)] +pub struct ExtDebugReportFn { + pub create_debug_report_callback_ext: PFN_vkCreateDebugReportCallbackEXT, + pub destroy_debug_report_callback_ext: PFN_vkDestroyDebugReportCallbackEXT, + pub debug_report_message_ext: PFN_vkDebugReportMessageEXT, +} +unsafe impl Send for ExtDebugReportFn {} +unsafe impl Sync for ExtDebugReportFn {} +impl ExtDebugReportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_debug_report_callback_ext: unsafe { + unsafe extern "system" fn create_debug_report_callback_ext( + _instance: Instance, + _p_create_info: *const DebugReportCallbackCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_callback: *mut DebugReportCallbackEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_debug_report_callback_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDebugReportCallbackEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_debug_report_callback_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_debug_report_callback_ext: unsafe { + unsafe extern "system" fn destroy_debug_report_callback_ext( + _instance: Instance, + _callback: DebugReportCallbackEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_debug_report_callback_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDebugReportCallbackEXT\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_debug_report_callback_ext + } else { + ::std::mem::transmute(val) + } + }, + debug_report_message_ext: unsafe { + unsafe extern "system" fn debug_report_message_ext( + _instance: Instance, + _flags: DebugReportFlagsEXT, + _object_type: DebugReportObjectTypeEXT, + _object: u64, + _location: usize, + _message_code: i32, + _p_layer_prefix: *const c_char, + _p_message: *const c_char, + ) { + panic!(concat!( + "Unable to load ", + stringify!(debug_report_message_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDebugReportMessageEXT\0"); + let val = _f(cname); + if val.is_null() { + debug_report_message_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_debug_report'"] +impl DebugReportObjectTypeEXT { + pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000); + pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000); +} +#[doc = "Generated from 'VK_EXT_debug_report'"] +impl ObjectType { + pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(1_000_011_000); +} +#[doc = "Generated from 'VK_EXT_debug_report'"] +impl Result { + pub const ERROR_VALIDATION_FAILED_EXT: Self = Self(-1_000_011_001); +} +#[doc = "Generated from 'VK_EXT_debug_report'"] +impl StructureType { + pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = Self(1_000_011_000); +} +impl NvGlslShaderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_glsl_shader\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvGlslShaderFn {} +unsafe impl Send for NvGlslShaderFn {} +unsafe impl Sync for NvGlslShaderFn {} +impl NvGlslShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_glsl_shader'"] +impl Result { + pub const ERROR_INVALID_SHADER_NV: Self = Self(-1_000_012_000); +} +impl ExtDepthRangeUnrestrictedFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_range_unrestricted\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDepthRangeUnrestrictedFn {} +unsafe impl Send for ExtDepthRangeUnrestrictedFn {} +unsafe impl Sync for ExtDepthRangeUnrestrictedFn {} +impl ExtDepthRangeUnrestrictedFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSamplerMirrorClampToEdgeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_sampler_mirror_clamp_to_edge\0", + ) + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct KhrSamplerMirrorClampToEdgeFn {} +unsafe impl Send for KhrSamplerMirrorClampToEdgeFn {} +unsafe impl Sync for KhrSamplerMirrorClampToEdgeFn {} +impl KhrSamplerMirrorClampToEdgeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_sampler_mirror_clamp_to_edge'"] +impl SamplerAddressMode { + #[doc = "Note that this defines what was previously a core enum, and so uses the 'value' attribute rather than 'offset', and does not have a suffix. This is a special case, and should not be repeated"] + pub const MIRROR_CLAMP_TO_EDGE: Self = Self(4); + #[deprecated = "Alias introduced for consistency with extension suffixing rules"] + pub const MIRROR_CLAMP_TO_EDGE_KHR: Self = Self::MIRROR_CLAMP_TO_EDGE; +} +impl ImgFilterCubicFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_filter_cubic\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ImgFilterCubicFn {} +unsafe impl Send for ImgFilterCubicFn {} +unsafe impl Sync for ImgFilterCubicFn {} +impl ImgFilterCubicFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_IMG_filter_cubic'"] +impl Filter { + pub const CUBIC_IMG: Self = Self::CUBIC_EXT; +} +#[doc = "Generated from 'VK_IMG_filter_cubic'"] +impl FormatFeatureFlags { + #[doc = "Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled"] + pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC_EXT; +} +impl AmdExtension17Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_17\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension17Fn {} +unsafe impl Send for AmdExtension17Fn {} +unsafe impl Sync for AmdExtension17Fn {} +impl AmdExtension17Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension18Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_18\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension18Fn {} +unsafe impl Send for AmdExtension18Fn {} +unsafe impl Sync for AmdExtension18Fn {} +impl AmdExtension18Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdRasterizationOrderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_rasterization_order\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdRasterizationOrderFn {} +unsafe impl Send for AmdRasterizationOrderFn {} +unsafe impl Sync for AmdRasterizationOrderFn {} +impl AmdRasterizationOrderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_rasterization_order'"] +impl StructureType { + pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = Self(1_000_018_000); +} +impl AmdExtension20Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_20\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension20Fn {} +unsafe impl Send for AmdExtension20Fn {} +unsafe impl Sync for AmdExtension20Fn {} +impl AmdExtension20Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderTrinaryMinmaxFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_trinary_minmax\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderTrinaryMinmaxFn {} +unsafe impl Send for AmdShaderTrinaryMinmaxFn {} +unsafe impl Sync for AmdShaderTrinaryMinmaxFn {} +impl AmdShaderTrinaryMinmaxFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderExplicitVertexParameterFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_AMD_shader_explicit_vertex_parameter\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderExplicitVertexParameterFn {} +unsafe impl Send for AmdShaderExplicitVertexParameterFn {} +unsafe impl Sync for AmdShaderExplicitVertexParameterFn {} +impl AmdShaderExplicitVertexParameterFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtDebugMarkerFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_marker\0") } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkDebugMarkerSetObjectTagEXT = unsafe extern "system" fn( + device: Device, + p_tag_info: *const DebugMarkerObjectTagInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDebugMarkerSetObjectNameEXT = unsafe extern "system" fn( + device: Device, + p_name_info: *const DebugMarkerObjectNameInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDebugMarkerBeginEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDebugMarkerEndEXT = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDebugMarkerInsertEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, +); +#[derive(Clone)] +pub struct ExtDebugMarkerFn { + pub debug_marker_set_object_tag_ext: PFN_vkDebugMarkerSetObjectTagEXT, + pub debug_marker_set_object_name_ext: PFN_vkDebugMarkerSetObjectNameEXT, + pub cmd_debug_marker_begin_ext: PFN_vkCmdDebugMarkerBeginEXT, + pub cmd_debug_marker_end_ext: PFN_vkCmdDebugMarkerEndEXT, + pub cmd_debug_marker_insert_ext: PFN_vkCmdDebugMarkerInsertEXT, +} +unsafe impl Send for ExtDebugMarkerFn {} +unsafe impl Sync for ExtDebugMarkerFn {} +impl ExtDebugMarkerFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + debug_marker_set_object_tag_ext: unsafe { + unsafe extern "system" fn debug_marker_set_object_tag_ext( + _device: Device, + _p_tag_info: *const DebugMarkerObjectTagInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(debug_marker_set_object_tag_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDebugMarkerSetObjectTagEXT\0", + ); + let val = _f(cname); + if val.is_null() { + debug_marker_set_object_tag_ext + } else { + ::std::mem::transmute(val) + } + }, + debug_marker_set_object_name_ext: unsafe { + unsafe extern "system" fn debug_marker_set_object_name_ext( + _device: Device, + _p_name_info: *const DebugMarkerObjectNameInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(debug_marker_set_object_name_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDebugMarkerSetObjectNameEXT\0", + ); + let val = _f(cname); + if val.is_null() { + debug_marker_set_object_name_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_debug_marker_begin_ext: unsafe { + unsafe extern "system" fn cmd_debug_marker_begin_ext( + _command_buffer: CommandBuffer, + _p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_begin_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerBeginEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_debug_marker_begin_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_debug_marker_end_ext: unsafe { + unsafe extern "system" fn cmd_debug_marker_end_ext(_command_buffer: CommandBuffer) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_end_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerEndEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_debug_marker_end_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_debug_marker_insert_ext: unsafe { + unsafe extern "system" fn cmd_debug_marker_insert_ext( + _command_buffer: CommandBuffer, + _p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_insert_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerInsertEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_debug_marker_insert_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_debug_marker'"] +impl StructureType { + pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = Self(1_000_022_000); + pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = Self(1_000_022_001); + pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = Self(1_000_022_002); +} +impl KhrVideoQueueFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") } + } + pub const SPEC_VERSION: u32 = 8u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_video_profile: *const VideoProfileInfoKHR, + p_capabilities: *mut VideoCapabilitiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR, + p_video_format_property_count: *mut u32, + p_video_format_properties: *mut VideoFormatPropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateVideoSessionKHR = unsafe extern "system" fn( + device: Device, + p_create_info: *const VideoSessionCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_video_session: *mut VideoSessionKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn( + device: Device, + video_session: VideoSessionKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn( + device: Device, + video_session: VideoSessionKHR, + p_memory_requirements_count: *mut u32, + p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn( + device: Device, + video_session: VideoSessionKHR, + bind_session_memory_info_count: u32, + p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn( + device: Device, + p_create_info: *const VideoSessionParametersCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_video_session_parameters: *mut VideoSessionParametersKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn( + device: Device, + video_session_parameters: VideoSessionParametersKHR, + p_update_info: *const VideoSessionParametersUpdateInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn( + device: Device, + video_session_parameters: VideoSessionParametersKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_begin_info: *const VideoBeginCodingInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_end_coding_info: *const VideoEndCodingInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_coding_control_info: *const VideoCodingControlInfoKHR, +); +#[derive(Clone)] +pub struct KhrVideoQueueFn { + pub get_physical_device_video_capabilities_khr: PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR, + pub get_physical_device_video_format_properties_khr: + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR, + pub create_video_session_khr: PFN_vkCreateVideoSessionKHR, + pub destroy_video_session_khr: PFN_vkDestroyVideoSessionKHR, + pub get_video_session_memory_requirements_khr: PFN_vkGetVideoSessionMemoryRequirementsKHR, + pub bind_video_session_memory_khr: PFN_vkBindVideoSessionMemoryKHR, + pub create_video_session_parameters_khr: PFN_vkCreateVideoSessionParametersKHR, + pub update_video_session_parameters_khr: PFN_vkUpdateVideoSessionParametersKHR, + pub destroy_video_session_parameters_khr: PFN_vkDestroyVideoSessionParametersKHR, + pub cmd_begin_video_coding_khr: PFN_vkCmdBeginVideoCodingKHR, + pub cmd_end_video_coding_khr: PFN_vkCmdEndVideoCodingKHR, + pub cmd_control_video_coding_khr: PFN_vkCmdControlVideoCodingKHR, +} +unsafe impl Send for KhrVideoQueueFn {} +unsafe impl Sync for KhrVideoQueueFn {} +impl KhrVideoQueueFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_video_capabilities_khr: unsafe { + unsafe extern "system" fn get_physical_device_video_capabilities_khr( + _physical_device: PhysicalDevice, + _p_video_profile: *const VideoProfileInfoKHR, + _p_capabilities: *mut VideoCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_video_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceVideoCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_video_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_video_format_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_video_format_properties_khr( + _physical_device: PhysicalDevice, + _p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR, + _p_video_format_property_count: *mut u32, + _p_video_format_properties: *mut VideoFormatPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_video_format_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceVideoFormatPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_video_format_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + create_video_session_khr: unsafe { + unsafe extern "system" fn create_video_session_khr( + _device: Device, + _p_create_info: *const VideoSessionCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_video_session: *mut VideoSessionKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_video_session_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateVideoSessionKHR\0"); + let val = _f(cname); + if val.is_null() { + create_video_session_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_video_session_khr: unsafe { + unsafe extern "system" fn destroy_video_session_khr( + _device: Device, + _video_session: VideoSessionKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_video_session_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyVideoSessionKHR\0"); + let val = _f(cname); + if val.is_null() { + destroy_video_session_khr + } else { + ::std::mem::transmute(val) + } + }, + get_video_session_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_video_session_memory_requirements_khr( + _device: Device, + _video_session: VideoSessionKHR, + _p_memory_requirements_count: *mut u32, + _p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_video_session_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetVideoSessionMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_video_session_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + bind_video_session_memory_khr: unsafe { + unsafe extern "system" fn bind_video_session_memory_khr( + _device: Device, + _video_session: VideoSessionKHR, + _bind_session_memory_info_count: u32, + _p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_video_session_memory_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBindVideoSessionMemoryKHR\0", + ); + let val = _f(cname); + if val.is_null() { + bind_video_session_memory_khr + } else { + ::std::mem::transmute(val) + } + }, + create_video_session_parameters_khr: unsafe { + unsafe extern "system" fn create_video_session_parameters_khr( + _device: Device, + _p_create_info: *const VideoSessionParametersCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_video_session_parameters: *mut VideoSessionParametersKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_video_session_parameters_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateVideoSessionParametersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_video_session_parameters_khr + } else { + ::std::mem::transmute(val) + } + }, + update_video_session_parameters_khr: unsafe { + unsafe extern "system" fn update_video_session_parameters_khr( + _device: Device, + _video_session_parameters: VideoSessionParametersKHR, + _p_update_info: *const VideoSessionParametersUpdateInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(update_video_session_parameters_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkUpdateVideoSessionParametersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + update_video_session_parameters_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_video_session_parameters_khr: unsafe { + unsafe extern "system" fn destroy_video_session_parameters_khr( + _device: Device, + _video_session_parameters: VideoSessionParametersKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_video_session_parameters_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyVideoSessionParametersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_video_session_parameters_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_video_coding_khr: unsafe { + unsafe extern "system" fn cmd_begin_video_coding_khr( + _command_buffer: CommandBuffer, + _p_begin_info: *const VideoBeginCodingInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_video_coding_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginVideoCodingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_video_coding_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_video_coding_khr: unsafe { + unsafe extern "system" fn cmd_end_video_coding_khr( + _command_buffer: CommandBuffer, + _p_end_coding_info: *const VideoEndCodingInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_video_coding_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndVideoCodingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_video_coding_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_control_video_coding_khr: unsafe { + unsafe extern "system" fn cmd_control_video_coding_khr( + _command_buffer: CommandBuffer, + _p_coding_control_info: *const VideoCodingControlInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_control_video_coding_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdControlVideoCodingKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_control_video_coding_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl ObjectType { + #[doc = "VkVideoSessionKHR"] + pub const VIDEO_SESSION_KHR: Self = Self(1_000_023_000); + #[doc = "VkVideoSessionParametersKHR"] + pub const VIDEO_SESSION_PARAMETERS_KHR: Self = Self(1_000_023_001); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl QueryResultFlags { + pub const WITH_STATUS_KHR: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl QueryType { + pub const RESULT_STATUS_ONLY_KHR: Self = Self(1_000_023_000); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl Result { + pub const ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_000); + pub const ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_001); + pub const ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_002); + pub const ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_003); + pub const ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_004); + pub const ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_005); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl StructureType { + pub const VIDEO_PROFILE_INFO_KHR: Self = Self(1_000_023_000); + pub const VIDEO_CAPABILITIES_KHR: Self = Self(1_000_023_001); + pub const VIDEO_PICTURE_RESOURCE_INFO_KHR: Self = Self(1_000_023_002); + pub const VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: Self = Self(1_000_023_003); + pub const BIND_VIDEO_SESSION_MEMORY_INFO_KHR: Self = Self(1_000_023_004); + pub const VIDEO_SESSION_CREATE_INFO_KHR: Self = Self(1_000_023_005); + pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_023_006); + pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: Self = Self(1_000_023_007); + pub const VIDEO_BEGIN_CODING_INFO_KHR: Self = Self(1_000_023_008); + pub const VIDEO_END_CODING_INFO_KHR: Self = Self(1_000_023_009); + pub const VIDEO_CODING_CONTROL_INFO_KHR: Self = Self(1_000_023_010); + pub const VIDEO_REFERENCE_SLOT_INFO_KHR: Self = Self(1_000_023_011); + pub const QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: Self = Self(1_000_023_012); + pub const VIDEO_PROFILE_LIST_INFO_KHR: Self = Self(1_000_023_013); + pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: Self = Self(1_000_023_014); + pub const VIDEO_FORMAT_PROPERTIES_KHR: Self = Self(1_000_023_015); + pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: Self = Self(1_000_023_016); +} +impl KhrVideoDecodeQueueFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_queue\0") } + } + pub const SPEC_VERSION: u32 = 7u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_decode_info: *const VideoDecodeInfoKHR, +); +#[derive(Clone)] +pub struct KhrVideoDecodeQueueFn { + pub cmd_decode_video_khr: PFN_vkCmdDecodeVideoKHR, +} +unsafe impl Send for KhrVideoDecodeQueueFn {} +unsafe impl Sync for KhrVideoDecodeQueueFn {} +impl KhrVideoDecodeQueueFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_decode_video_khr: unsafe { + unsafe extern "system" fn cmd_decode_video_khr( + _command_buffer: CommandBuffer, + _p_decode_info: *const VideoDecodeInfoKHR, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_decode_video_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecodeVideoKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_decode_video_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl AccessFlags2 { + pub const VIDEO_DECODE_READ_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const VIDEO_DECODE_WRITE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl BufferUsageFlags { + pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b10_0000_0000_0000); + pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl FormatFeatureFlags { + pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl FormatFeatureFlags2 { + pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl ImageLayout { + pub const VIDEO_DECODE_DST_KHR: Self = Self(1_000_024_000); + pub const VIDEO_DECODE_SRC_KHR: Self = Self(1_000_024_001); + pub const VIDEO_DECODE_DPB_KHR: Self = Self(1_000_024_002); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl ImageUsageFlags { + pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000); + pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b1000_0000_0000); + pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl PipelineStageFlags2 { + pub const VIDEO_DECODE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl QueueFlags { + pub const VIDEO_DECODE_KHR: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl StructureType { + pub const VIDEO_DECODE_INFO_KHR: Self = Self(1_000_024_000); + pub const VIDEO_DECODE_CAPABILITIES_KHR: Self = Self(1_000_024_001); + pub const VIDEO_DECODE_USAGE_INFO_KHR: Self = Self(1_000_024_002); +} +impl AmdGcnShaderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gcn_shader\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdGcnShaderFn {} +unsafe impl Send for AmdGcnShaderFn {} +unsafe impl Sync for AmdGcnShaderFn {} +impl AmdGcnShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvDedicatedAllocationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_dedicated_allocation\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvDedicatedAllocationFn {} +unsafe impl Send for NvDedicatedAllocationFn {} +unsafe impl Sync for NvDedicatedAllocationFn {} +impl NvDedicatedAllocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_dedicated_allocation'"] +impl StructureType { + pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = Self(1_000_026_000); + pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = Self(1_000_026_001); + pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_026_002); +} +impl ExtExtension28Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_28\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension28Fn {} +unsafe impl Send for ExtExtension28Fn {} +unsafe impl Sync for ExtExtension28Fn {} +impl ExtExtension28Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtTransformFeedbackFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_transform_feedback\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindTransformFeedbackBuffersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_binding: u32, + binding_count: u32, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + p_sizes: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginTransformFeedbackEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_counter_buffer: u32, + counter_buffer_count: u32, + p_counter_buffers: *const Buffer, + p_counter_buffer_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndTransformFeedbackEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_counter_buffer: u32, + counter_buffer_count: u32, + p_counter_buffers: *const Buffer, + p_counter_buffer_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginQueryIndexedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: u32, + flags: QueryControlFlags, + index: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndQueryIndexedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: u32, + index: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndirectByteCountEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + instance_count: u32, + first_instance: u32, + counter_buffer: Buffer, + counter_buffer_offset: DeviceSize, + counter_offset: u32, + vertex_stride: u32, +); +#[derive(Clone)] +pub struct ExtTransformFeedbackFn { + pub cmd_bind_transform_feedback_buffers_ext: PFN_vkCmdBindTransformFeedbackBuffersEXT, + pub cmd_begin_transform_feedback_ext: PFN_vkCmdBeginTransformFeedbackEXT, + pub cmd_end_transform_feedback_ext: PFN_vkCmdEndTransformFeedbackEXT, + pub cmd_begin_query_indexed_ext: PFN_vkCmdBeginQueryIndexedEXT, + pub cmd_end_query_indexed_ext: PFN_vkCmdEndQueryIndexedEXT, + pub cmd_draw_indirect_byte_count_ext: PFN_vkCmdDrawIndirectByteCountEXT, +} +unsafe impl Send for ExtTransformFeedbackFn {} +unsafe impl Sync for ExtTransformFeedbackFn {} +impl ExtTransformFeedbackFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_bind_transform_feedback_buffers_ext: unsafe { + unsafe extern "system" fn cmd_bind_transform_feedback_buffers_ext( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + _p_sizes: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_transform_feedback_buffers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindTransformFeedbackBuffersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_transform_feedback_buffers_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_transform_feedback_ext: unsafe { + unsafe extern "system" fn cmd_begin_transform_feedback_ext( + _command_buffer: CommandBuffer, + _first_counter_buffer: u32, + _counter_buffer_count: u32, + _p_counter_buffers: *const Buffer, + _p_counter_buffer_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_transform_feedback_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBeginTransformFeedbackEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_begin_transform_feedback_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_transform_feedback_ext: unsafe { + unsafe extern "system" fn cmd_end_transform_feedback_ext( + _command_buffer: CommandBuffer, + _first_counter_buffer: u32, + _counter_buffer_count: u32, + _p_counter_buffers: *const Buffer, + _p_counter_buffer_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_transform_feedback_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdEndTransformFeedbackEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_end_transform_feedback_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_query_indexed_ext: unsafe { + unsafe extern "system" fn cmd_begin_query_indexed_ext( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + _flags: QueryControlFlags, + _index: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_query_indexed_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQueryIndexedEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_query_indexed_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_query_indexed_ext: unsafe { + unsafe extern "system" fn cmd_end_query_indexed_ext( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + _index: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_query_indexed_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQueryIndexedEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_query_indexed_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indirect_byte_count_ext: unsafe { + unsafe extern "system" fn cmd_draw_indirect_byte_count_ext( + _command_buffer: CommandBuffer, + _instance_count: u32, + _first_instance: u32, + _counter_buffer: Buffer, + _counter_buffer_offset: DeviceSize, + _counter_offset: u32, + _vertex_stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_byte_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawIndirectByteCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect_byte_count_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl AccessFlags { + pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl BufferUsageFlags { + pub const TRANSFORM_FEEDBACK_BUFFER_EXT: Self = Self(0b1000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl PipelineStageFlags { + pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl QueryType { + pub const TRANSFORM_FEEDBACK_STREAM_EXT: Self = Self(1_000_028_004); +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: Self = Self(1_000_028_000); + pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: Self = Self(1_000_028_001); + pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: Self = Self(1_000_028_002); +} +impl NvxBinaryImportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_binary_import\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCuModuleNVX = unsafe extern "system" fn( + device: Device, + p_create_info: *const CuModuleCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_module: *mut CuModuleNVX, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCuFunctionNVX = unsafe extern "system" fn( + device: Device, + p_create_info: *const CuFunctionCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_function: *mut CuFunctionNVX, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCuModuleNVX = unsafe extern "system" fn( + device: Device, + module: CuModuleNVX, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCuFunctionNVX = unsafe extern "system" fn( + device: Device, + function: CuFunctionNVX, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCuLaunchKernelNVX = + unsafe extern "system" fn(command_buffer: CommandBuffer, p_launch_info: *const CuLaunchInfoNVX); +#[derive(Clone)] +pub struct NvxBinaryImportFn { + pub create_cu_module_nvx: PFN_vkCreateCuModuleNVX, + pub create_cu_function_nvx: PFN_vkCreateCuFunctionNVX, + pub destroy_cu_module_nvx: PFN_vkDestroyCuModuleNVX, + pub destroy_cu_function_nvx: PFN_vkDestroyCuFunctionNVX, + pub cmd_cu_launch_kernel_nvx: PFN_vkCmdCuLaunchKernelNVX, +} +unsafe impl Send for NvxBinaryImportFn {} +unsafe impl Sync for NvxBinaryImportFn {} +impl NvxBinaryImportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_cu_module_nvx: unsafe { + unsafe extern "system" fn create_cu_module_nvx( + _device: Device, + _p_create_info: *const CuModuleCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_module: *mut CuModuleNVX, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_cu_module_nvx))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuModuleNVX\0"); + let val = _f(cname); + if val.is_null() { + create_cu_module_nvx + } else { + ::std::mem::transmute(val) + } + }, + create_cu_function_nvx: unsafe { + unsafe extern "system" fn create_cu_function_nvx( + _device: Device, + _p_create_info: *const CuFunctionCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_function: *mut CuFunctionNVX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_cu_function_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuFunctionNVX\0"); + let val = _f(cname); + if val.is_null() { + create_cu_function_nvx + } else { + ::std::mem::transmute(val) + } + }, + destroy_cu_module_nvx: unsafe { + unsafe extern "system" fn destroy_cu_module_nvx( + _device: Device, + _module: CuModuleNVX, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_cu_module_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuModuleNVX\0"); + let val = _f(cname); + if val.is_null() { + destroy_cu_module_nvx + } else { + ::std::mem::transmute(val) + } + }, + destroy_cu_function_nvx: unsafe { + unsafe extern "system" fn destroy_cu_function_nvx( + _device: Device, + _function: CuFunctionNVX, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_cu_function_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuFunctionNVX\0"); + let val = _f(cname); + if val.is_null() { + destroy_cu_function_nvx + } else { + ::std::mem::transmute(val) + } + }, + cmd_cu_launch_kernel_nvx: unsafe { + unsafe extern "system" fn cmd_cu_launch_kernel_nvx( + _command_buffer: CommandBuffer, + _p_launch_info: *const CuLaunchInfoNVX, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_cu_launch_kernel_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCuLaunchKernelNVX\0"); + let val = _f(cname); + if val.is_null() { + cmd_cu_launch_kernel_nvx + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl DebugReportObjectTypeEXT { + pub const CU_MODULE_NVX: Self = Self(1_000_029_000); + pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl ObjectType { + pub const CU_MODULE_NVX: Self = Self(1_000_029_000); + pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl StructureType { + pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1_000_029_000); + pub const CU_FUNCTION_CREATE_INFO_NVX: Self = Self(1_000_029_001); + pub const CU_LAUNCH_INFO_NVX: Self = Self(1_000_029_002); +} +impl NvxImageViewHandleFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_image_view_handle\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewHandleNVX = + unsafe extern "system" fn(device: Device, p_info: *const ImageViewHandleInfoNVX) -> u32; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewAddressNVX = unsafe extern "system" fn( + device: Device, + image_view: ImageView, + p_properties: *mut ImageViewAddressPropertiesNVX, +) -> Result; +#[derive(Clone)] +pub struct NvxImageViewHandleFn { + pub get_image_view_handle_nvx: PFN_vkGetImageViewHandleNVX, + pub get_image_view_address_nvx: PFN_vkGetImageViewAddressNVX, +} +unsafe impl Send for NvxImageViewHandleFn {} +unsafe impl Sync for NvxImageViewHandleFn {} +impl NvxImageViewHandleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_image_view_handle_nvx: unsafe { + unsafe extern "system" fn get_image_view_handle_nvx( + _device: Device, + _p_info: *const ImageViewHandleInfoNVX, + ) -> u32 { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_handle_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewHandleNVX\0"); + let val = _f(cname); + if val.is_null() { + get_image_view_handle_nvx + } else { + ::std::mem::transmute(val) + } + }, + get_image_view_address_nvx: unsafe { + unsafe extern "system" fn get_image_view_address_nvx( + _device: Device, + _image_view: ImageView, + _p_properties: *mut ImageViewAddressPropertiesNVX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_address_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewAddressNVX\0"); + let val = _f(cname); + if val.is_null() { + get_image_view_address_nvx + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NVX_image_view_handle'"] +impl StructureType { + pub const IMAGE_VIEW_HANDLE_INFO_NVX: Self = Self(1_000_030_000); + pub const IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: Self = Self(1_000_030_001); +} +impl AmdExtension32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_32\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension32Fn {} +unsafe impl Send for AmdExtension32Fn {} +unsafe impl Sync for AmdExtension32Fn {} +impl AmdExtension32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension33Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_33\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension33Fn {} +unsafe impl Send for AmdExtension33Fn {} +unsafe impl Sync for AmdExtension33Fn {} +impl AmdExtension33Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdDrawIndirectCountFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_draw_indirect_count\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndirectCount = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +); +#[derive(Clone)] +pub struct AmdDrawIndirectCountFn { + pub cmd_draw_indirect_count_amd: PFN_vkCmdDrawIndirectCount, + pub cmd_draw_indexed_indirect_count_amd: PFN_vkCmdDrawIndexedIndirectCount, +} +unsafe impl Send for AmdDrawIndirectCountFn {} +unsafe impl Sync for AmdDrawIndirectCountFn {} +impl AmdDrawIndirectCountFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_indirect_count_amd: unsafe { + unsafe extern "system" fn cmd_draw_indirect_count_amd( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect_count_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect_count_amd: unsafe { + unsafe extern "system" fn cmd_draw_indexed_indirect_count_amd( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count_amd) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawIndexedIndirectCountAMD\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed_indirect_count_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl AmdExtension35Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_35\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension35Fn {} +unsafe impl Send for AmdExtension35Fn {} +unsafe impl Sync for AmdExtension35Fn {} +impl AmdExtension35Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdNegativeViewportHeightFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_negative_viewport_height\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdNegativeViewportHeightFn {} +unsafe impl Send for AmdNegativeViewportHeightFn {} +unsafe impl Sync for AmdNegativeViewportHeightFn {} +impl AmdNegativeViewportHeightFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdGpuShaderHalfFloatFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_half_float\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct AmdGpuShaderHalfFloatFn {} +unsafe impl Send for AmdGpuShaderHalfFloatFn {} +unsafe impl Sync for AmdGpuShaderHalfFloatFn {} +impl AmdGpuShaderHalfFloatFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderBallotFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_ballot\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderBallotFn {} +unsafe impl Send for AmdShaderBallotFn {} +unsafe impl Sync for AmdShaderBallotFn {} +impl AmdShaderBallotFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtVideoEncodeH264Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") } + } + pub const SPEC_VERSION: u32 = 9u32; +} +#[derive(Clone)] +pub struct ExtVideoEncodeH264Fn {} +unsafe impl Send for ExtVideoEncodeH264Fn {} +unsafe impl Sync for ExtVideoEncodeH264Fn {} +impl ExtVideoEncodeH264Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_video_encode_h264'"] +impl StructureType { + pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000); + pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_001); + pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_002); + pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_003); + pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004); + pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: Self = Self(1_000_038_005); + pub const VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT: Self = Self(1_000_038_006); + pub const VIDEO_ENCODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_038_007); + pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008); + pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009); + pub const VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT: Self = Self(1_000_038_010); +} +#[doc = "Generated from 'VK_EXT_video_encode_h264'"] +impl VideoCodecOperationFlagsKHR { + pub const ENCODE_H264_EXT: Self = Self(0b1_0000_0000_0000_0000); +} +impl ExtVideoEncodeH265Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") } + } + pub const SPEC_VERSION: u32 = 9u32; +} +#[derive(Clone)] +pub struct ExtVideoEncodeH265Fn {} +unsafe impl Send for ExtVideoEncodeH265Fn {} +unsafe impl Sync for ExtVideoEncodeH265Fn {} +impl ExtVideoEncodeH265Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000); + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_001); + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_002); + pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_003); + pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004); + pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: Self = Self(1_000_039_005); + pub const VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT: Self = Self(1_000_039_006); + pub const VIDEO_ENCODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_039_007); + pub const VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT: Self = Self(1_000_039_008); + pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_009); + pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_010); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl VideoCodecOperationFlagsKHR { + pub const ENCODE_H265_EXT: Self = Self(0b10_0000_0000_0000_0000); +} +impl KhrVideoDecodeH264Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h264\0") } + } + pub const SPEC_VERSION: u32 = 8u32; +} +#[derive(Clone)] +pub struct KhrVideoDecodeH264Fn {} +unsafe impl Send for KhrVideoDecodeH264Fn {} +unsafe impl Sync for KhrVideoDecodeH264Fn {} +impl KhrVideoDecodeH264Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_video_decode_h264'"] +impl StructureType { + pub const VIDEO_DECODE_H264_CAPABILITIES_KHR: Self = Self(1_000_040_000); + pub const VIDEO_DECODE_H264_PICTURE_INFO_KHR: Self = Self(1_000_040_001); + pub const VIDEO_DECODE_H264_PROFILE_INFO_KHR: Self = Self(1_000_040_003); + pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_040_004); + pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_040_005); + pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: Self = Self(1_000_040_006); +} +#[doc = "Generated from 'VK_KHR_video_decode_h264'"] +impl VideoCodecOperationFlagsKHR { + pub const DECODE_H264: Self = Self(0b1); +} +impl AmdTextureGatherBiasLodFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_texture_gather_bias_lod\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdTextureGatherBiasLodFn {} +unsafe impl Send for AmdTextureGatherBiasLodFn {} +unsafe impl Sync for AmdTextureGatherBiasLodFn {} +impl AmdTextureGatherBiasLodFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_texture_gather_bias_lod'"] +impl StructureType { + pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = Self(1_000_041_000); +} +impl AmdShaderInfoFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_info\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderInfoAMD = unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + shader_stage: ShaderStageFlags, + info_type: ShaderInfoTypeAMD, + p_info_size: *mut usize, + p_info: *mut c_void, +) -> Result; +#[derive(Clone)] +pub struct AmdShaderInfoFn { + pub get_shader_info_amd: PFN_vkGetShaderInfoAMD, +} +unsafe impl Send for AmdShaderInfoFn {} +unsafe impl Sync for AmdShaderInfoFn {} +impl AmdShaderInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_shader_info_amd: unsafe { + unsafe extern "system" fn get_shader_info_amd( + _device: Device, + _pipeline: Pipeline, + _shader_stage: ShaderStageFlags, + _info_type: ShaderInfoTypeAMD, + _p_info_size: *mut usize, + _p_info: *mut c_void, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_shader_info_amd))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetShaderInfoAMD\0"); + let val = _f(cname); + if val.is_null() { + get_shader_info_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl AmdExtension44Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_44\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension44Fn {} +unsafe impl Send for AmdExtension44Fn {} +unsafe impl Sync for AmdExtension44Fn {} +impl AmdExtension44Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrDynamicRenderingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dynamic_rendering\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginRendering = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_rendering_info: *const RenderingInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndRendering = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[derive(Clone)] +pub struct KhrDynamicRenderingFn { + pub cmd_begin_rendering_khr: PFN_vkCmdBeginRendering, + pub cmd_end_rendering_khr: PFN_vkCmdEndRendering, +} +unsafe impl Send for KhrDynamicRenderingFn {} +unsafe impl Sync for KhrDynamicRenderingFn {} +impl KhrDynamicRenderingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_begin_rendering_khr: unsafe { + unsafe extern "system" fn cmd_begin_rendering_khr( + _command_buffer: CommandBuffer, + _p_rendering_info: *const RenderingInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_rendering_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_rendering_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_rendering_khr: unsafe { + unsafe extern "system" fn cmd_end_rendering_khr(_command_buffer: CommandBuffer) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_rendering_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_rendering_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl AttachmentStoreOp { + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl PipelineCreateFlags { + pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self(0b10_0000_0000_0000_0000_0000); + pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const RENDERING_INFO_KHR: Self = Self::RENDERING_INFO; + pub const RENDERING_ATTACHMENT_INFO_KHR: Self = Self::RENDERING_ATTACHMENT_INFO; + pub const PIPELINE_RENDERING_CREATE_INFO_KHR: Self = Self::PIPELINE_RENDERING_CREATE_INFO; + pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: Self = + Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; + pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_044_006); + pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: Self = Self(1_000_044_007); + pub const ATTACHMENT_SAMPLE_COUNT_INFO_AMD: Self = Self(1_000_044_008); + pub const ATTACHMENT_SAMPLE_COUNT_INFO_NV: Self = Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: Self = Self(1_000_044_009); +} +impl AmdExtension46Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_46\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension46Fn {} +unsafe impl Send for AmdExtension46Fn {} +unsafe impl Sync for AmdExtension46Fn {} +impl AmdExtension46Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderImageLoadStoreLodFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_image_load_store_lod\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderImageLoadStoreLodFn {} +unsafe impl Send for AmdShaderImageLoadStoreLodFn {} +unsafe impl Sync for AmdShaderImageLoadStoreLodFn {} +impl AmdShaderImageLoadStoreLodFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvxExtension48Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_extension_48\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvxExtension48Fn {} +unsafe impl Send for NvxExtension48Fn {} +unsafe impl Sync for NvxExtension48Fn {} +impl NvxExtension48Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension49Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_49\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension49Fn {} +unsafe impl Send for GoogleExtension49Fn {} +unsafe impl Sync for GoogleExtension49Fn {} +impl GoogleExtension49Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpStreamDescriptorSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_stream_descriptor_surface\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateStreamDescriptorSurfaceGGP = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct GgpStreamDescriptorSurfaceFn { + pub create_stream_descriptor_surface_ggp: PFN_vkCreateStreamDescriptorSurfaceGGP, +} +unsafe impl Send for GgpStreamDescriptorSurfaceFn {} +unsafe impl Sync for GgpStreamDescriptorSurfaceFn {} +impl GgpStreamDescriptorSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_stream_descriptor_surface_ggp: unsafe { + unsafe extern "system" fn create_stream_descriptor_surface_ggp( + _instance: Instance, + _p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_stream_descriptor_surface_ggp) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateStreamDescriptorSurfaceGGP\0", + ); + let val = _f(cname); + if val.is_null() { + create_stream_descriptor_surface_ggp + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_GGP_stream_descriptor_surface'"] +impl StructureType { + pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: Self = Self(1_000_049_000); +} +impl NvCornerSampledImageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_corner_sampled_image\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvCornerSampledImageFn {} +unsafe impl Send for NvCornerSampledImageFn {} +unsafe impl Sync for NvCornerSampledImageFn {} +impl NvCornerSampledImageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_corner_sampled_image'"] +impl ImageCreateFlags { + pub const CORNER_SAMPLED_NV: Self = Self(0b10_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_corner_sampled_image'"] +impl StructureType { + pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: Self = Self(1_000_050_000); +} +impl NvExtension52Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_52\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension52Fn {} +unsafe impl Send for NvExtension52Fn {} +unsafe impl Sync for NvExtension52Fn {} +impl NvExtension52Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension53Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_53\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension53Fn {} +unsafe impl Send for NvExtension53Fn {} +unsafe impl Sync for NvExtension53Fn {} +impl NvExtension53Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrMultiviewFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_multiview\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrMultiviewFn {} +unsafe impl Send for KhrMultiviewFn {} +unsafe impl Sync for KhrMultiviewFn {} +impl KhrMultiviewFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_multiview'"] +impl DependencyFlags { + pub const VIEW_LOCAL_KHR: Self = Self::VIEW_LOCAL; +} +#[doc = "Generated from 'VK_KHR_multiview'"] +impl StructureType { + pub const RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: Self = Self::RENDER_PASS_MULTIVIEW_CREATE_INFO; + pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; +} +impl ImgFormatPvrtcFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_format_pvrtc\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ImgFormatPvrtcFn {} +unsafe impl Send for ImgFormatPvrtcFn {} +unsafe impl Sync for ImgFormatPvrtcFn {} +impl ImgFormatPvrtcFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_IMG_format_pvrtc'"] +impl Format { + pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_000); + pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_001); + pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_002); + pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_003); + pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_004); + pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_005); + pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_006); + pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_007); +} +impl NvExternalMemoryCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_capabilities\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + external_handle_type: ExternalMemoryHandleTypeFlagsNV, + p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, + ) -> Result; +#[derive(Clone)] +pub struct NvExternalMemoryCapabilitiesFn { + pub get_physical_device_external_image_format_properties_nv: + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, +} +unsafe impl Send for NvExternalMemoryCapabilitiesFn {} +unsafe impl Sync for NvExternalMemoryCapabilitiesFn {} +impl NvExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_external_image_format_properties_nv: unsafe { + unsafe extern "system" fn get_physical_device_external_image_format_properties_nv( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _tiling: ImageTiling, + _usage: ImageUsageFlags, + _flags: ImageCreateFlags, + _external_handle_type: ExternalMemoryHandleTypeFlagsNV, + _p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_image_format_properties_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalImageFormatPropertiesNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_image_format_properties_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl NvExternalMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvExternalMemoryFn {} +unsafe impl Send for NvExternalMemoryFn {} +unsafe impl Sync for NvExternalMemoryFn {} +impl NvExternalMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_external_memory'"] +impl StructureType { + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = Self(1_000_056_000); + pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_056_001); +} +impl NvExternalMemoryWin32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_win32\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryWin32HandleNV = unsafe extern "system" fn( + device: Device, + memory: DeviceMemory, + handle_type: ExternalMemoryHandleTypeFlagsNV, + p_handle: *mut HANDLE, +) -> Result; +#[derive(Clone)] +pub struct NvExternalMemoryWin32Fn { + pub get_memory_win32_handle_nv: PFN_vkGetMemoryWin32HandleNV, +} +unsafe impl Send for NvExternalMemoryWin32Fn {} +unsafe impl Sync for NvExternalMemoryWin32Fn {} +impl NvExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_win32_handle_nv: unsafe { + unsafe extern "system" fn get_memory_win32_handle_nv( + _device: Device, + _memory: DeviceMemory, + _handle_type: ExternalMemoryHandleTypeFlagsNV, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleNV\0"); + let val = _f(cname); + if val.is_null() { + get_memory_win32_handle_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_external_memory_win32'"] +impl StructureType { + pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_000); + pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_001); +} +impl NvWin32KeyedMutexFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_win32_keyed_mutex\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvWin32KeyedMutexFn {} +unsafe impl Send for NvWin32KeyedMutexFn {} +unsafe impl Sync for NvWin32KeyedMutexFn {} +impl NvWin32KeyedMutexFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_win32_keyed_mutex'"] +impl StructureType { + pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = Self(1_000_058_000); +} +impl KhrGetPhysicalDeviceProperties2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_get_physical_device_properties2\0", + ) + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFeatures2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_features: *mut PhysicalDeviceFeatures2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_properties: *mut PhysicalDeviceProperties2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFormatProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + p_format_properties: *mut FormatProperties2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + p_image_format_properties: *mut ImageFormatProperties2, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_queue_family_property_count: *mut u32, + p_queue_family_properties: *mut QueueFamilyProperties2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceMemoryProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_memory_properties: *mut PhysicalDeviceMemoryProperties2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + p_property_count: *mut u32, + p_properties: *mut SparseImageFormatProperties2, +); +#[derive(Clone)] +pub struct KhrGetPhysicalDeviceProperties2Fn { + pub get_physical_device_features2_khr: PFN_vkGetPhysicalDeviceFeatures2, + pub get_physical_device_properties2_khr: PFN_vkGetPhysicalDeviceProperties2, + pub get_physical_device_format_properties2_khr: PFN_vkGetPhysicalDeviceFormatProperties2, + pub get_physical_device_image_format_properties2_khr: + PFN_vkGetPhysicalDeviceImageFormatProperties2, + pub get_physical_device_queue_family_properties2_khr: + PFN_vkGetPhysicalDeviceQueueFamilyProperties2, + pub get_physical_device_memory_properties2_khr: PFN_vkGetPhysicalDeviceMemoryProperties2, + pub get_physical_device_sparse_image_format_properties2_khr: + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2, +} +unsafe impl Send for KhrGetPhysicalDeviceProperties2Fn {} +unsafe impl Sync for KhrGetPhysicalDeviceProperties2Fn {} +impl KhrGetPhysicalDeviceProperties2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_features2_khr: unsafe { + unsafe extern "system" fn get_physical_device_features2_khr( + _physical_device: PhysicalDevice, + _p_features: *mut PhysicalDeviceFeatures2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_features2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFeatures2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_features2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_properties2_khr( + _physical_device: PhysicalDevice, + _p_properties: *mut PhysicalDeviceProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_format_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_format_properties2_khr( + _physical_device: PhysicalDevice, + _format: Format, + _p_format_properties: *mut FormatProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_format_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFormatProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_format_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_image_format_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_image_format_properties2_khr( + _physical_device: PhysicalDevice, + _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + _p_image_format_properties: *mut ImageFormatProperties2, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_image_format_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceImageFormatProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_image_format_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_queue_family_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_queue_family_properties2_khr( + _physical_device: PhysicalDevice, + _p_queue_family_property_count: *mut u32, + _p_queue_family_properties: *mut QueueFamilyProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_queue_family_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceQueueFamilyProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_queue_family_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_memory_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_memory_properties2_khr( + _physical_device: PhysicalDevice, + _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_memory_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceMemoryProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_memory_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_sparse_image_format_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_sparse_image_format_properties2_khr( + _physical_device: PhysicalDevice, + _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + _p_property_count: *mut u32, + _p_properties: *mut SparseImageFormatProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_sparse_image_format_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSparseImageFormatProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_sparse_image_format_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FEATURES_2_KHR: Self = Self::PHYSICAL_DEVICE_FEATURES_2; + pub const PHYSICAL_DEVICE_PROPERTIES_2_KHR: Self = Self::PHYSICAL_DEVICE_PROPERTIES_2; + pub const FORMAT_PROPERTIES_2_KHR: Self = Self::FORMAT_PROPERTIES_2; + pub const IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::IMAGE_FORMAT_PROPERTIES_2; + pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: Self = + Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; + pub const QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self::QUEUE_FAMILY_PROPERTIES_2; + pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: Self = + Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; + pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2; + pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: Self = + Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; +} +impl KhrDeviceGroupFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group\0") } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupPeerMemoryFeatures = unsafe extern "system" fn( + device: Device, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, + p_peer_memory_features: *mut PeerMemoryFeatureFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDeviceMask = + unsafe extern "system" fn(command_buffer: CommandBuffer, device_mask: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatchBase = unsafe extern "system" fn( + command_buffer: CommandBuffer, + base_group_x: u32, + base_group_y: u32, + base_group_z: u32, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, +); +#[derive(Clone)] +pub struct KhrDeviceGroupFn { + pub get_device_group_peer_memory_features_khr: PFN_vkGetDeviceGroupPeerMemoryFeatures, + pub cmd_set_device_mask_khr: PFN_vkCmdSetDeviceMask, + pub cmd_dispatch_base_khr: PFN_vkCmdDispatchBase, + pub get_device_group_present_capabilities_khr: + crate::vk::PFN_vkGetDeviceGroupPresentCapabilitiesKHR, + pub get_device_group_surface_present_modes_khr: + crate::vk::PFN_vkGetDeviceGroupSurfacePresentModesKHR, + pub get_physical_device_present_rectangles_khr: + crate::vk::PFN_vkGetPhysicalDevicePresentRectanglesKHR, + pub acquire_next_image2_khr: crate::vk::PFN_vkAcquireNextImage2KHR, +} +unsafe impl Send for KhrDeviceGroupFn {} +unsafe impl Sync for KhrDeviceGroupFn {} +impl KhrDeviceGroupFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_device_group_peer_memory_features_khr: unsafe { + unsafe extern "system" fn get_device_group_peer_memory_features_khr( + _device: Device, + _heap_index: u32, + _local_device_index: u32, + _remote_device_index: u32, + _p_peer_memory_features: *mut PeerMemoryFeatureFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_peer_memory_features_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupPeerMemoryFeaturesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_peer_memory_features_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_device_mask_khr: unsafe { + unsafe extern "system" fn cmd_set_device_mask_khr( + _command_buffer: CommandBuffer, + _device_mask: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_device_mask_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMaskKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_device_mask_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_base_khr: unsafe { + unsafe extern "system" fn cmd_dispatch_base_khr( + _command_buffer: CommandBuffer, + _base_group_x: u32, + _base_group_y: u32, + _base_group_z: u32, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_dispatch_base_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBaseKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_base_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_present_capabilities_khr: unsafe { + unsafe extern "system" fn get_device_group_present_capabilities_khr( + _device: Device, + _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_present_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupPresentCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_present_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_surface_present_modes_khr: unsafe { + unsafe extern "system" fn get_device_group_surface_present_modes_khr( + _device: Device, + _surface: SurfaceKHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupSurfacePresentModesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_surface_present_modes_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_present_rectangles_khr: unsafe { + unsafe extern "system" fn get_physical_device_present_rectangles_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_rect_count: *mut u32, + _p_rects: *mut Rect2D, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_present_rectangles_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDevicePresentRectanglesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_present_rectangles_khr + } else { + ::std::mem::transmute(val) + } + }, + acquire_next_image2_khr: unsafe { + unsafe extern "system" fn acquire_next_image2_khr( + _device: Device, + _p_acquire_info: *const AcquireNextImageInfoKHR, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + acquire_next_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl DependencyFlags { + pub const DEVICE_GROUP_KHR: Self = Self::DEVICE_GROUP; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl ImageCreateFlags { + pub const SPLIT_INSTANCE_BIND_REGIONS_KHR: Self = Self::SPLIT_INSTANCE_BIND_REGIONS; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl MemoryAllocateFlags { + pub const DEVICE_MASK_KHR: Self = Self::DEVICE_MASK; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl PeerMemoryFeatureFlags { + pub const COPY_SRC_KHR: Self = Self::COPY_SRC; + pub const COPY_DST_KHR: Self = Self::COPY_DST; + pub const GENERIC_SRC_KHR: Self = Self::GENERIC_SRC; + pub const GENERIC_DST_KHR: Self = Self::GENERIC_DST; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl PipelineCreateFlags { + pub const VIEW_INDEX_FROM_DEVICE_INDEX_KHR: Self = Self::VIEW_INDEX_FROM_DEVICE_INDEX; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl StructureType { + pub const MEMORY_ALLOCATE_FLAGS_INFO_KHR: Self = Self::MEMORY_ALLOCATE_FLAGS_INFO; + pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: Self = + Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; + pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: Self = + Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; + pub const DEVICE_GROUP_SUBMIT_INFO_KHR: Self = Self::DEVICE_GROUP_SUBMIT_INFO; + pub const DEVICE_GROUP_BIND_SPARSE_INFO_KHR: Self = Self::DEVICE_GROUP_BIND_SPARSE_INFO; + pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: Self = + Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; + pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: Self = + Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; +} +impl ExtValidationFlagsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_flags\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtValidationFlagsFn {} +unsafe impl Send for ExtValidationFlagsFn {} +unsafe impl Sync for ExtValidationFlagsFn {} +impl ExtValidationFlagsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_validation_flags'"] +impl StructureType { + pub const VALIDATION_FLAGS_EXT: Self = Self(1_000_061_000); +} +impl NnViSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NN_vi_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateViSurfaceNN = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const ViSurfaceCreateInfoNN, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct NnViSurfaceFn { + pub create_vi_surface_nn: PFN_vkCreateViSurfaceNN, +} +unsafe impl Send for NnViSurfaceFn {} +unsafe impl Sync for NnViSurfaceFn {} +impl NnViSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_vi_surface_nn: unsafe { + unsafe extern "system" fn create_vi_surface_nn( + _instance: Instance, + _p_create_info: *const ViSurfaceCreateInfoNN, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_vi_surface_nn))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateViSurfaceNN\0"); + let val = _f(cname); + if val.is_null() { + create_vi_surface_nn + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NN_vi_surface'"] +impl StructureType { + pub const VI_SURFACE_CREATE_INFO_NN: Self = Self(1_000_062_000); +} +impl KhrShaderDrawParametersFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_draw_parameters\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderDrawParametersFn {} +unsafe impl Send for KhrShaderDrawParametersFn {} +unsafe impl Sync for KhrShaderDrawParametersFn {} +impl KhrShaderDrawParametersFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderSubgroupBallotFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_ballot\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderSubgroupBallotFn {} +unsafe impl Send for ExtShaderSubgroupBallotFn {} +unsafe impl Sync for ExtShaderSubgroupBallotFn {} +impl ExtShaderSubgroupBallotFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderSubgroupVoteFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_vote\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderSubgroupVoteFn {} +unsafe impl Send for ExtShaderSubgroupVoteFn {} +unsafe impl Sync for ExtShaderSubgroupVoteFn {} +impl ExtShaderSubgroupVoteFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtTextureCompressionAstcHdrFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_texture_compression_astc_hdr\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtTextureCompressionAstcHdrFn {} +unsafe impl Send for ExtTextureCompressionAstcHdrFn {} +unsafe impl Sync for ExtTextureCompressionAstcHdrFn {} +impl ExtTextureCompressionAstcHdrFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"] +impl Format { + pub const ASTC_4X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_4X4_SFLOAT_BLOCK; + pub const ASTC_5X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X4_SFLOAT_BLOCK; + pub const ASTC_5X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X5_SFLOAT_BLOCK; + pub const ASTC_6X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X5_SFLOAT_BLOCK; + pub const ASTC_6X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X6_SFLOAT_BLOCK; + pub const ASTC_8X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X5_SFLOAT_BLOCK; + pub const ASTC_8X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X6_SFLOAT_BLOCK; + pub const ASTC_8X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X8_SFLOAT_BLOCK; + pub const ASTC_10X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X5_SFLOAT_BLOCK; + pub const ASTC_10X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X6_SFLOAT_BLOCK; + pub const ASTC_10X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X8_SFLOAT_BLOCK; + pub const ASTC_10X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X10_SFLOAT_BLOCK; + pub const ASTC_12X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X10_SFLOAT_BLOCK; + pub const ASTC_12X12_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X12_SFLOAT_BLOCK; +} +#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; +} +impl ExtAstcDecodeModeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_astc_decode_mode\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtAstcDecodeModeFn {} +unsafe impl Send for ExtAstcDecodeModeFn {} +unsafe impl Sync for ExtAstcDecodeModeFn {} +impl ExtAstcDecodeModeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_astc_decode_mode'"] +impl StructureType { + pub const IMAGE_VIEW_ASTC_DECODE_MODE_EXT: Self = Self(1_000_067_000); + pub const PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: Self = Self(1_000_067_001); +} +impl ExtPipelineRobustnessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_robustness\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPipelineRobustnessFn {} +unsafe impl Send for ExtPipelineRobustnessFn {} +unsafe impl Sync for ExtPipelineRobustnessFn {} +impl ExtPipelineRobustnessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pipeline_robustness'"] +impl StructureType { + pub const PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: Self = Self(1_000_068_000); + pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: Self = Self(1_000_068_001); + pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: Self = Self(1_000_068_002); +} +impl KhrMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance1\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkTrimCommandPool = unsafe extern "system" fn( + device: Device, + command_pool: CommandPool, + flags: CommandPoolTrimFlags, +); +#[derive(Clone)] +pub struct KhrMaintenance1Fn { + pub trim_command_pool_khr: PFN_vkTrimCommandPool, +} +unsafe impl Send for KhrMaintenance1Fn {} +unsafe impl Sync for KhrMaintenance1Fn {} +impl KhrMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + trim_command_pool_khr: unsafe { + unsafe extern "system" fn trim_command_pool_khr( + _device: Device, + _command_pool: CommandPool, + _flags: CommandPoolTrimFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(trim_command_pool_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPoolKHR\0"); + let val = _f(cname); + if val.is_null() { + trim_command_pool_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_maintenance1'"] +impl FormatFeatureFlags { + pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC; + pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST; +} +#[doc = "Generated from 'VK_KHR_maintenance1'"] +impl ImageCreateFlags { + pub const TYPE_2D_ARRAY_COMPATIBLE_KHR: Self = Self::TYPE_2D_ARRAY_COMPATIBLE; +} +#[doc = "Generated from 'VK_KHR_maintenance1'"] +impl Result { + pub const ERROR_OUT_OF_POOL_MEMORY_KHR: Self = Self::ERROR_OUT_OF_POOL_MEMORY; +} +impl KhrDeviceGroupCreationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group_creation\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkEnumeratePhysicalDeviceGroups = unsafe extern "system" fn( + instance: Instance, + p_physical_device_group_count: *mut u32, + p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, +) -> Result; +#[derive(Clone)] +pub struct KhrDeviceGroupCreationFn { + pub enumerate_physical_device_groups_khr: PFN_vkEnumeratePhysicalDeviceGroups, +} +unsafe impl Send for KhrDeviceGroupCreationFn {} +unsafe impl Sync for KhrDeviceGroupCreationFn {} +impl KhrDeviceGroupCreationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + enumerate_physical_device_groups_khr: unsafe { + unsafe extern "system" fn enumerate_physical_device_groups_khr( + _instance: Instance, + _p_physical_device_group_count: *mut u32, + _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_physical_device_groups_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumeratePhysicalDeviceGroupsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_physical_device_groups_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_device_group_creation'"] +impl MemoryHeapFlags { + pub const MULTI_INSTANCE_KHR: Self = Self::MULTI_INSTANCE; +} +#[doc = "Generated from 'VK_KHR_device_group_creation'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_GROUP_PROPERTIES; + pub const DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: Self = Self::DEVICE_GROUP_DEVICE_CREATE_INFO; +} +impl KhrExternalMemoryCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_external_memory_capabilities\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceExternalBufferProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + p_external_buffer_properties: *mut ExternalBufferProperties, +); +#[derive(Clone)] +pub struct KhrExternalMemoryCapabilitiesFn { + pub get_physical_device_external_buffer_properties_khr: + PFN_vkGetPhysicalDeviceExternalBufferProperties, +} +unsafe impl Send for KhrExternalMemoryCapabilitiesFn {} +unsafe impl Sync for KhrExternalMemoryCapabilitiesFn {} +impl KhrExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_external_buffer_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_external_buffer_properties_khr( + _physical_device: PhysicalDevice, + _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + _p_external_buffer_properties: *mut ExternalBufferProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_buffer_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalBufferPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_buffer_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"] +impl ExternalMemoryFeatureFlags { + pub const DEDICATED_ONLY_KHR: Self = Self::DEDICATED_ONLY; + pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE; + pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE; +} +#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"] +impl ExternalMemoryHandleTypeFlags { + pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD; + pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32; + pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT; + pub const D3D11_TEXTURE_KHR: Self = Self::D3D11_TEXTURE; + pub const D3D11_TEXTURE_KMT_KHR: Self = Self::D3D11_TEXTURE_KMT; + pub const D3D12_HEAP_KHR: Self = Self::D3D12_HEAP; + pub const D3D12_RESOURCE_KHR: Self = Self::D3D12_RESOURCE; +} +#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: Self = + Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; + pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: Self = Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES; + pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: Self = + Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; + pub const EXTERNAL_BUFFER_PROPERTIES_KHR: Self = Self::EXTERNAL_BUFFER_PROPERTIES; + pub const PHYSICAL_DEVICE_ID_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_ID_PROPERTIES; +} +impl KhrExternalMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrExternalMemoryFn {} +unsafe impl Send for KhrExternalMemoryFn {} +unsafe impl Sync for KhrExternalMemoryFn {} +impl KhrExternalMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_external_memory'"] +impl Result { + pub const ERROR_INVALID_EXTERNAL_HANDLE_KHR: Self = Self::ERROR_INVALID_EXTERNAL_HANDLE; +} +#[doc = "Generated from 'VK_KHR_external_memory'"] +impl StructureType { + pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: Self = + Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO; + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: Self = Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + pub const EXPORT_MEMORY_ALLOCATE_INFO_KHR: Self = Self::EXPORT_MEMORY_ALLOCATE_INFO; +} +impl KhrExternalMemoryWin32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_win32\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryWin32HandlePropertiesKHR = unsafe extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + handle: HANDLE, + p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalMemoryWin32Fn { + pub get_memory_win32_handle_khr: PFN_vkGetMemoryWin32HandleKHR, + pub get_memory_win32_handle_properties_khr: PFN_vkGetMemoryWin32HandlePropertiesKHR, +} +unsafe impl Send for KhrExternalMemoryWin32Fn {} +unsafe impl Sync for KhrExternalMemoryWin32Fn {} +impl KhrExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_win32_handle_khr: unsafe { + unsafe extern "system" fn get_memory_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleKHR\0"); + let val = _f(cname); + if val.is_null() { + get_memory_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + get_memory_win32_handle_properties_khr: unsafe { + unsafe extern "system" fn get_memory_win32_handle_properties_khr( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _handle: HANDLE, + _p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryWin32HandlePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_win32_handle_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_memory_win32'"] +impl StructureType { + pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_000); + pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_001); + pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = Self(1_000_073_002); + pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_003); +} +impl KhrExternalMemoryFdFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_fd\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryFdKHR = unsafe extern "system" fn( + device: Device, + p_get_fd_info: *const MemoryGetFdInfoKHR, + p_fd: *mut c_int, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryFdPropertiesKHR = unsafe extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + fd: c_int, + p_memory_fd_properties: *mut MemoryFdPropertiesKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalMemoryFdFn { + pub get_memory_fd_khr: PFN_vkGetMemoryFdKHR, + pub get_memory_fd_properties_khr: PFN_vkGetMemoryFdPropertiesKHR, +} +unsafe impl Send for KhrExternalMemoryFdFn {} +unsafe impl Sync for KhrExternalMemoryFdFn {} +impl KhrExternalMemoryFdFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_fd_khr: unsafe { + unsafe extern "system" fn get_memory_fd_khr( + _device: Device, + _p_get_fd_info: *const MemoryGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_memory_fd_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryFdKHR\0"); + let val = _f(cname); + if val.is_null() { + get_memory_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + get_memory_fd_properties_khr: unsafe { + unsafe extern "system" fn get_memory_fd_properties_khr( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _fd: c_int, + _p_memory_fd_properties: *mut MemoryFdPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_fd_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryFdPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_fd_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_memory_fd'"] +impl StructureType { + pub const IMPORT_MEMORY_FD_INFO_KHR: Self = Self(1_000_074_000); + pub const MEMORY_FD_PROPERTIES_KHR: Self = Self(1_000_074_001); + pub const MEMORY_GET_FD_INFO_KHR: Self = Self(1_000_074_002); +} +impl KhrWin32KeyedMutexFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_keyed_mutex\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrWin32KeyedMutexFn {} +unsafe impl Send for KhrWin32KeyedMutexFn {} +unsafe impl Sync for KhrWin32KeyedMutexFn {} +impl KhrWin32KeyedMutexFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_win32_keyed_mutex'"] +impl StructureType { + pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = Self(1_000_075_000); +} +impl KhrExternalSemaphoreCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_external_semaphore_capabilities\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + p_external_semaphore_properties: *mut ExternalSemaphoreProperties, +); +#[derive(Clone)] +pub struct KhrExternalSemaphoreCapabilitiesFn { + pub get_physical_device_external_semaphore_properties_khr: + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties, +} +unsafe impl Send for KhrExternalSemaphoreCapabilitiesFn {} +unsafe impl Sync for KhrExternalSemaphoreCapabilitiesFn {} +impl KhrExternalSemaphoreCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_external_semaphore_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_external_semaphore_properties_khr( + _physical_device: PhysicalDevice, + _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_semaphore_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_semaphore_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"] +impl ExternalSemaphoreFeatureFlags { + pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE; + pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE; +} +#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"] +impl ExternalSemaphoreHandleTypeFlags { + pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD; + pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32; + pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT; + pub const D3D12_FENCE_KHR: Self = Self::D3D12_FENCE; + pub const SYNC_FD_KHR: Self = Self::SYNC_FD; +} +#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: Self = + Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; + pub const EXTERNAL_SEMAPHORE_PROPERTIES_KHR: Self = Self::EXTERNAL_SEMAPHORE_PROPERTIES; +} +impl KhrExternalSemaphoreFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrExternalSemaphoreFn {} +unsafe impl Send for KhrExternalSemaphoreFn {} +unsafe impl Sync for KhrExternalSemaphoreFn {} +impl KhrExternalSemaphoreFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_external_semaphore'"] +impl SemaphoreImportFlags { + pub const TEMPORARY_KHR: Self = Self::TEMPORARY; +} +#[doc = "Generated from 'VK_KHR_external_semaphore'"] +impl StructureType { + pub const EXPORT_SEMAPHORE_CREATE_INFO_KHR: Self = Self::EXPORT_SEMAPHORE_CREATE_INFO; +} +impl KhrExternalSemaphoreWin32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_win32\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportSemaphoreWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalSemaphoreWin32Fn { + pub import_semaphore_win32_handle_khr: PFN_vkImportSemaphoreWin32HandleKHR, + pub get_semaphore_win32_handle_khr: PFN_vkGetSemaphoreWin32HandleKHR, +} +unsafe impl Send for KhrExternalSemaphoreWin32Fn {} +unsafe impl Sync for KhrExternalSemaphoreWin32Fn {} +impl KhrExternalSemaphoreWin32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_semaphore_win32_handle_khr: unsafe { + unsafe extern "system" fn import_semaphore_win32_handle_khr( + _device: Device, + _p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_win32_handle_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkImportSemaphoreWin32HandleKHR\0", + ); + let val = _f(cname); + if val.is_null() { + import_semaphore_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + get_semaphore_win32_handle_khr: unsafe { + unsafe extern "system" fn get_semaphore_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_win32_handle_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSemaphoreWin32HandleKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_semaphore_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_semaphore_win32'"] +impl StructureType { + pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_000); + pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_001); + pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = Self(1_000_078_002); + pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_003); +} +impl KhrExternalSemaphoreFdFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_fd\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportSemaphoreFdKHR = unsafe extern "system" fn( + device: Device, + p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreFdKHR = unsafe extern "system" fn( + device: Device, + p_get_fd_info: *const SemaphoreGetFdInfoKHR, + p_fd: *mut c_int, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalSemaphoreFdFn { + pub import_semaphore_fd_khr: PFN_vkImportSemaphoreFdKHR, + pub get_semaphore_fd_khr: PFN_vkGetSemaphoreFdKHR, +} +unsafe impl Send for KhrExternalSemaphoreFdFn {} +unsafe impl Sync for KhrExternalSemaphoreFdFn {} +impl KhrExternalSemaphoreFdFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_semaphore_fd_khr: unsafe { + unsafe extern "system" fn import_semaphore_fd_khr( + _device: Device, + _p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_fd_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkImportSemaphoreFdKHR\0"); + let val = _f(cname); + if val.is_null() { + import_semaphore_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + get_semaphore_fd_khr: unsafe { + unsafe extern "system" fn get_semaphore_fd_khr( + _device: Device, + _p_get_fd_info: *const SemaphoreGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_semaphore_fd_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSemaphoreFdKHR\0"); + let val = _f(cname); + if val.is_null() { + get_semaphore_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_semaphore_fd'"] +impl StructureType { + pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = Self(1_000_079_000); + pub const SEMAPHORE_GET_FD_INFO_KHR: Self = Self(1_000_079_001); +} +impl KhrPushDescriptorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_push_descriptor\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPushDescriptorSetKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: u32, + descriptor_write_count: u32, + p_descriptor_writes: *const WriteDescriptorSet, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: u32, + p_data: *const c_void, +); +#[derive(Clone)] +pub struct KhrPushDescriptorFn { + pub cmd_push_descriptor_set_khr: PFN_vkCmdPushDescriptorSetKHR, + pub cmd_push_descriptor_set_with_template_khr: PFN_vkCmdPushDescriptorSetWithTemplateKHR, +} +unsafe impl Send for KhrPushDescriptorFn {} +unsafe impl Sync for KhrPushDescriptorFn {} +impl KhrPushDescriptorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_push_descriptor_set_khr: unsafe { + unsafe extern "system" fn cmd_push_descriptor_set_khr( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _set: u32, + _descriptor_write_count: u32, + _p_descriptor_writes: *const WriteDescriptorSet, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushDescriptorSetKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_push_descriptor_set_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_push_descriptor_set_with_template_khr: unsafe { + unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr( + _command_buffer: CommandBuffer, + _descriptor_update_template: DescriptorUpdateTemplate, + _layout: PipelineLayout, + _set: u32, + _p_data: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_with_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdPushDescriptorSetWithTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_push_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_push_descriptor'"] +impl DescriptorSetLayoutCreateFlags { + #[doc = "Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR"] + pub const PUSH_DESCRIPTOR_KHR: Self = Self(0b1); +} +#[doc = "Generated from 'VK_KHR_push_descriptor'"] +impl DescriptorUpdateTemplateType { + #[doc = "Create descriptor update template for pushed descriptor updates"] + pub const PUSH_DESCRIPTORS_KHR: Self = Self(1); +} +#[doc = "Generated from 'VK_KHR_push_descriptor'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = Self(1_000_080_000); +} +impl ExtConditionalRenderingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conditional_rendering\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginConditionalRenderingEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndConditionalRenderingEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer); +#[derive(Clone)] +pub struct ExtConditionalRenderingFn { + pub cmd_begin_conditional_rendering_ext: PFN_vkCmdBeginConditionalRenderingEXT, + pub cmd_end_conditional_rendering_ext: PFN_vkCmdEndConditionalRenderingEXT, +} +unsafe impl Send for ExtConditionalRenderingFn {} +unsafe impl Sync for ExtConditionalRenderingFn {} +impl ExtConditionalRenderingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_begin_conditional_rendering_ext: unsafe { + unsafe extern "system" fn cmd_begin_conditional_rendering_ext( + _command_buffer: CommandBuffer, + _p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_conditional_rendering_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBeginConditionalRenderingEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_begin_conditional_rendering_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_conditional_rendering_ext: unsafe { + unsafe extern "system" fn cmd_end_conditional_rendering_ext( + _command_buffer: CommandBuffer, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_conditional_rendering_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdEndConditionalRenderingEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_end_conditional_rendering_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_conditional_rendering'"] +impl AccessFlags { + #[doc = "read access flag for reading conditional rendering predicate"] + pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_conditional_rendering'"] +impl BufferUsageFlags { + #[doc = "Specifies the buffer can be used as predicate in conditional rendering"] + pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from 'VK_EXT_conditional_rendering'"] +impl PipelineStageFlags { + #[doc = "A pipeline stage for conditional rendering predicate fetch"] + pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_conditional_rendering'"] +impl StructureType { + pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: Self = Self(1_000_081_000); + pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: Self = Self(1_000_081_001); + pub const CONDITIONAL_RENDERING_BEGIN_INFO_EXT: Self = Self(1_000_081_002); +} +impl KhrShaderFloat16Int8Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float16_int8\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderFloat16Int8Fn {} +unsafe impl Send for KhrShaderFloat16Int8Fn {} +unsafe impl Sync for KhrShaderFloat16Int8Fn {} +impl KhrShaderFloat16Int8Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_float16_int8'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + pub const PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; +} +impl Khr16bitStorageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_16bit_storage\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct Khr16bitStorageFn {} +unsafe impl Send for Khr16bitStorageFn {} +unsafe impl Sync for Khr16bitStorageFn {} +impl Khr16bitStorageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_16bit_storage'"] +impl StructureType { + pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; +} +impl KhrIncrementalPresentFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_incremental_present\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct KhrIncrementalPresentFn {} +unsafe impl Send for KhrIncrementalPresentFn {} +unsafe impl Sync for KhrIncrementalPresentFn {} +impl KhrIncrementalPresentFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_incremental_present'"] +impl StructureType { + pub const PRESENT_REGIONS_KHR: Self = Self(1_000_084_000); +} +impl KhrDescriptorUpdateTemplateFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_descriptor_update_template\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDescriptorUpdateTemplate = unsafe extern "system" fn( + device: Device, + p_create_info: *const DescriptorUpdateTemplateCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_update_template: *mut DescriptorUpdateTemplate, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDescriptorUpdateTemplate = unsafe extern "system" fn( + device: Device, + descriptor_update_template: DescriptorUpdateTemplate, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkUpdateDescriptorSetWithTemplate = unsafe extern "system" fn( + device: Device, + descriptor_set: DescriptorSet, + descriptor_update_template: DescriptorUpdateTemplate, + p_data: *const c_void, +); +#[derive(Clone)] +pub struct KhrDescriptorUpdateTemplateFn { + pub create_descriptor_update_template_khr: PFN_vkCreateDescriptorUpdateTemplate, + pub destroy_descriptor_update_template_khr: PFN_vkDestroyDescriptorUpdateTemplate, + pub update_descriptor_set_with_template_khr: PFN_vkUpdateDescriptorSetWithTemplate, + pub cmd_push_descriptor_set_with_template_khr: + crate::vk::PFN_vkCmdPushDescriptorSetWithTemplateKHR, +} +unsafe impl Send for KhrDescriptorUpdateTemplateFn {} +unsafe impl Sync for KhrDescriptorUpdateTemplateFn {} +impl KhrDescriptorUpdateTemplateFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_descriptor_update_template_khr: unsafe { + unsafe extern "system" fn create_descriptor_update_template_khr( + _device: Device, + _p_create_info: *const DescriptorUpdateTemplateCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_descriptor_update_template: *mut DescriptorUpdateTemplate, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_update_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDescriptorUpdateTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_descriptor_update_template_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_descriptor_update_template_khr: unsafe { + unsafe extern "system" fn destroy_descriptor_update_template_khr( + _device: Device, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_update_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDescriptorUpdateTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_descriptor_update_template_khr + } else { + ::std::mem::transmute(val) + } + }, + update_descriptor_set_with_template_khr: unsafe { + unsafe extern "system" fn update_descriptor_set_with_template_khr( + _device: Device, + _descriptor_set: DescriptorSet, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_data: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(update_descriptor_set_with_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkUpdateDescriptorSetWithTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + update_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_push_descriptor_set_with_template_khr: unsafe { + unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr( + _command_buffer: CommandBuffer, + _descriptor_update_template: DescriptorUpdateTemplate, + _layout: PipelineLayout, + _set: u32, + _p_data: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_with_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdPushDescriptorSetWithTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_push_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_descriptor_update_template'"] +impl DebugReportObjectTypeEXT { + pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE; +} +#[doc = "Generated from 'VK_KHR_descriptor_update_template'"] +impl DescriptorUpdateTemplateType { + pub const DESCRIPTOR_SET_KHR: Self = Self::DESCRIPTOR_SET; +} +#[doc = "Generated from 'VK_KHR_descriptor_update_template'"] +impl ObjectType { + pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE; +} +#[doc = "Generated from 'VK_KHR_descriptor_update_template'"] +impl StructureType { + pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: Self = + Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; +} +impl NvxDeviceGeneratedCommandsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_device_generated_commands\0") + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct NvxDeviceGeneratedCommandsFn {} +unsafe impl Send for NvxDeviceGeneratedCommandsFn {} +unsafe impl Sync for NvxDeviceGeneratedCommandsFn {} +impl NvxDeviceGeneratedCommandsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvClipSpaceWScalingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_clip_space_w_scaling\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportWScalingNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_viewport_w_scalings: *const ViewportWScalingNV, +); +#[derive(Clone)] +pub struct NvClipSpaceWScalingFn { + pub cmd_set_viewport_w_scaling_nv: PFN_vkCmdSetViewportWScalingNV, +} +unsafe impl Send for NvClipSpaceWScalingFn {} +unsafe impl Sync for NvClipSpaceWScalingFn {} +impl NvClipSpaceWScalingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_viewport_w_scaling_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_w_scaling_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewport_w_scalings: *const ViewportWScalingNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_w_scaling_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWScalingNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_w_scaling_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"] +impl DynamicState { + pub const VIEWPORT_W_SCALING_NV: Self = Self(1_000_087_000); +} +#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = Self(1_000_087_000); +} +impl ExtDirectModeDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_direct_mode_display\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseDisplayEXT = + unsafe extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result; +#[derive(Clone)] +pub struct ExtDirectModeDisplayFn { + pub release_display_ext: PFN_vkReleaseDisplayEXT, +} +unsafe impl Send for ExtDirectModeDisplayFn {} +unsafe impl Sync for ExtDirectModeDisplayFn {} +impl ExtDirectModeDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + release_display_ext: unsafe { + unsafe extern "system" fn release_display_ext( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(release_display_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkReleaseDisplayEXT\0"); + let val = _f(cname); + if val.is_null() { + release_display_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtAcquireXlibDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_xlib_display\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireXlibDisplayEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + dpy: *mut Display, + display: DisplayKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetRandROutputDisplayEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + dpy: *mut Display, + rr_output: RROutput, + p_display: *mut DisplayKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtAcquireXlibDisplayFn { + pub acquire_xlib_display_ext: PFN_vkAcquireXlibDisplayEXT, + pub get_rand_r_output_display_ext: PFN_vkGetRandROutputDisplayEXT, +} +unsafe impl Send for ExtAcquireXlibDisplayFn {} +unsafe impl Sync for ExtAcquireXlibDisplayFn {} +impl ExtAcquireXlibDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + acquire_xlib_display_ext: unsafe { + unsafe extern "system" fn acquire_xlib_display_ext( + _physical_device: PhysicalDevice, + _dpy: *mut Display, + _display: DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_xlib_display_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireXlibDisplayEXT\0"); + let val = _f(cname); + if val.is_null() { + acquire_xlib_display_ext + } else { + ::std::mem::transmute(val) + } + }, + get_rand_r_output_display_ext: unsafe { + unsafe extern "system" fn get_rand_r_output_display_ext( + _physical_device: PhysicalDevice, + _dpy: *mut Display, + _rr_output: RROutput, + _p_display: *mut DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_rand_r_output_display_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRandROutputDisplayEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_rand_r_output_display_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtDisplaySurfaceCounterFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_surface_counter\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *mut SurfaceCapabilities2EXT, +) -> Result; +#[derive(Clone)] +pub struct ExtDisplaySurfaceCounterFn { + pub get_physical_device_surface_capabilities2_ext: + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT, +} +unsafe impl Send for ExtDisplaySurfaceCounterFn {} +unsafe impl Sync for ExtDisplaySurfaceCounterFn {} +impl ExtDisplaySurfaceCounterFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_surface_capabilities2_ext: unsafe { + unsafe extern "system" fn get_physical_device_surface_capabilities2_ext( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_capabilities: *mut SurfaceCapabilities2EXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceCapabilities2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_capabilities2_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_display_surface_counter'"] +impl StructureType { + pub const SURFACE_CAPABILITIES_2_EXT: Self = Self(1_000_090_000); +} +impl ExtDisplayControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_control\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkDisplayPowerControlEXT = unsafe extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_power_info: *const DisplayPowerInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkRegisterDeviceEventEXT = unsafe extern "system" fn( + device: Device, + p_device_event_info: *const DeviceEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkRegisterDisplayEventEXT = unsafe extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_event_info: *const DisplayEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainCounterEXT = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + counter: SurfaceCounterFlagsEXT, + p_counter_value: *mut u64, +) -> Result; +#[derive(Clone)] +pub struct ExtDisplayControlFn { + pub display_power_control_ext: PFN_vkDisplayPowerControlEXT, + pub register_device_event_ext: PFN_vkRegisterDeviceEventEXT, + pub register_display_event_ext: PFN_vkRegisterDisplayEventEXT, + pub get_swapchain_counter_ext: PFN_vkGetSwapchainCounterEXT, +} +unsafe impl Send for ExtDisplayControlFn {} +unsafe impl Sync for ExtDisplayControlFn {} +impl ExtDisplayControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + display_power_control_ext: unsafe { + unsafe extern "system" fn display_power_control_ext( + _device: Device, + _display: DisplayKHR, + _p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(display_power_control_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDisplayPowerControlEXT\0"); + let val = _f(cname); + if val.is_null() { + display_power_control_ext + } else { + ::std::mem::transmute(val) + } + }, + register_device_event_ext: unsafe { + unsafe extern "system" fn register_device_event_ext( + _device: Device, + _p_device_event_info: *const DeviceEventInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(register_device_event_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkRegisterDeviceEventEXT\0"); + let val = _f(cname); + if val.is_null() { + register_device_event_ext + } else { + ::std::mem::transmute(val) + } + }, + register_display_event_ext: unsafe { + unsafe extern "system" fn register_display_event_ext( + _device: Device, + _display: DisplayKHR, + _p_display_event_info: *const DisplayEventInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(register_display_event_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkRegisterDisplayEventEXT\0"); + let val = _f(cname); + if val.is_null() { + register_display_event_ext + } else { + ::std::mem::transmute(val) + } + }, + get_swapchain_counter_ext: unsafe { + unsafe extern "system" fn get_swapchain_counter_ext( + _device: Device, + _swapchain: SwapchainKHR, + _counter: SurfaceCounterFlagsEXT, + _p_counter_value: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_counter_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainCounterEXT\0"); + let val = _f(cname); + if val.is_null() { + get_swapchain_counter_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_display_control'"] +impl StructureType { + pub const DISPLAY_POWER_INFO_EXT: Self = Self(1_000_091_000); + pub const DEVICE_EVENT_INFO_EXT: Self = Self(1_000_091_001); + pub const DISPLAY_EVENT_INFO_EXT: Self = Self(1_000_091_002); + pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = Self(1_000_091_003); +} +impl GoogleDisplayTimingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_display_timing\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetRefreshCycleDurationGOOGLE = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPastPresentationTimingGOOGLE = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_presentation_timing_count: *mut u32, + p_presentation_timings: *mut PastPresentationTimingGOOGLE, +) -> Result; +#[derive(Clone)] +pub struct GoogleDisplayTimingFn { + pub get_refresh_cycle_duration_google: PFN_vkGetRefreshCycleDurationGOOGLE, + pub get_past_presentation_timing_google: PFN_vkGetPastPresentationTimingGOOGLE, +} +unsafe impl Send for GoogleDisplayTimingFn {} +unsafe impl Sync for GoogleDisplayTimingFn {} +impl GoogleDisplayTimingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_refresh_cycle_duration_google: unsafe { + unsafe extern "system" fn get_refresh_cycle_duration_google( + _device: Device, + _swapchain: SwapchainKHR, + _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_refresh_cycle_duration_google) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRefreshCycleDurationGOOGLE\0", + ); + let val = _f(cname); + if val.is_null() { + get_refresh_cycle_duration_google + } else { + ::std::mem::transmute(val) + } + }, + get_past_presentation_timing_google: unsafe { + unsafe extern "system" fn get_past_presentation_timing_google( + _device: Device, + _swapchain: SwapchainKHR, + _p_presentation_timing_count: *mut u32, + _p_presentation_timings: *mut PastPresentationTimingGOOGLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_past_presentation_timing_google) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPastPresentationTimingGOOGLE\0", + ); + let val = _f(cname); + if val.is_null() { + get_past_presentation_timing_google + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_GOOGLE_display_timing'"] +impl StructureType { + pub const PRESENT_TIMES_INFO_GOOGLE: Self = Self(1_000_092_000); +} +impl NvSampleMaskOverrideCoverageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_sample_mask_override_coverage\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvSampleMaskOverrideCoverageFn {} +unsafe impl Send for NvSampleMaskOverrideCoverageFn {} +unsafe impl Sync for NvSampleMaskOverrideCoverageFn {} +impl NvSampleMaskOverrideCoverageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvGeometryShaderPassthroughFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_geometry_shader_passthrough\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvGeometryShaderPassthroughFn {} +unsafe impl Send for NvGeometryShaderPassthroughFn {} +unsafe impl Sync for NvGeometryShaderPassthroughFn {} +impl NvGeometryShaderPassthroughFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvViewportArray2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_array2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvViewportArray2Fn {} +unsafe impl Send for NvViewportArray2Fn {} +unsafe impl Sync for NvViewportArray2Fn {} +impl NvViewportArray2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvxMultiviewPerViewAttributesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NVX_multiview_per_view_attributes\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvxMultiviewPerViewAttributesFn {} +unsafe impl Send for NvxMultiviewPerViewAttributesFn {} +unsafe impl Sync for NvxMultiviewPerViewAttributesFn {} +impl NvxMultiviewPerViewAttributesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self = + Self(1_000_097_000); +} +#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"] +impl SubpassDescriptionFlags { + pub const PER_VIEW_ATTRIBUTES_NVX: Self = Self(0b1); + pub const PER_VIEW_POSITION_X_ONLY_NVX: Self = Self(0b10); +} +impl NvViewportSwizzleFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_swizzle\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvViewportSwizzleFn {} +unsafe impl Send for NvViewportSwizzleFn {} +unsafe impl Sync for NvViewportSwizzleFn {} +impl NvViewportSwizzleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_viewport_swizzle'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = Self(1_000_098_000); +} +impl ExtDiscardRectanglesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_discard_rectangles\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_discard_rectangle: u32, + discard_rectangle_count: u32, + p_discard_rectangles: *const Rect2D, +); +#[derive(Clone)] +pub struct ExtDiscardRectanglesFn { + pub cmd_set_discard_rectangle_ext: PFN_vkCmdSetDiscardRectangleEXT, +} +unsafe impl Send for ExtDiscardRectanglesFn {} +unsafe impl Sync for ExtDiscardRectanglesFn {} +impl ExtDiscardRectanglesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_discard_rectangle_ext: unsafe { + unsafe extern "system" fn cmd_set_discard_rectangle_ext( + _command_buffer: CommandBuffer, + _first_discard_rectangle: u32, + _discard_rectangle_count: u32, + _p_discard_rectangles: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_discard_rectangle_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDiscardRectangleEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_discard_rectangle_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_discard_rectangles'"] +impl DynamicState { + pub const DISCARD_RECTANGLE_EXT: Self = Self(1_000_099_000); +} +#[doc = "Generated from 'VK_EXT_discard_rectangles'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = Self(1_000_099_000); + pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = Self(1_000_099_001); +} +impl NvExtension101Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_101\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension101Fn {} +unsafe impl Send for NvExtension101Fn {} +unsafe impl Sync for NvExtension101Fn {} +impl NvExtension101Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtConservativeRasterizationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conservative_rasterization\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtConservativeRasterizationFn {} +unsafe impl Send for ExtConservativeRasterizationFn {} +unsafe impl Sync for ExtConservativeRasterizationFn {} +impl ExtConservativeRasterizationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_conservative_rasterization'"] +impl StructureType { + pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_101_000); + pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = Self(1_000_101_001); +} +impl ExtDepthClipEnableFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_enable\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDepthClipEnableFn {} +unsafe impl Send for ExtDepthClipEnableFn {} +unsafe impl Sync for ExtDepthClipEnableFn {} +impl ExtDepthClipEnableFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_depth_clip_enable'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: Self = Self(1_000_102_000); + pub const PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: Self = Self(1_000_102_001); +} +impl NvExtension104Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_104\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension104Fn {} +unsafe impl Send for NvExtension104Fn {} +unsafe impl Sync for NvExtension104Fn {} +impl NvExtension104Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtSwapchainColorspaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_colorspace\0") } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[derive(Clone)] +pub struct ExtSwapchainColorspaceFn {} +unsafe impl Send for ExtSwapchainColorspaceFn {} +unsafe impl Sync for ExtSwapchainColorspaceFn {} +impl ExtSwapchainColorspaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"] +impl ColorSpaceKHR { + pub const DISPLAY_P3_NONLINEAR_EXT: Self = Self(1_000_104_001); + pub const EXTENDED_SRGB_LINEAR_EXT: Self = Self(1_000_104_002); + pub const DISPLAY_P3_LINEAR_EXT: Self = Self(1_000_104_003); + pub const DCI_P3_NONLINEAR_EXT: Self = Self(1_000_104_004); + pub const BT709_LINEAR_EXT: Self = Self(1_000_104_005); + pub const BT709_NONLINEAR_EXT: Self = Self(1_000_104_006); + pub const BT2020_LINEAR_EXT: Self = Self(1_000_104_007); + pub const HDR10_ST2084_EXT: Self = Self(1_000_104_008); + pub const DOLBYVISION_EXT: Self = Self(1_000_104_009); + pub const HDR10_HLG_EXT: Self = Self(1_000_104_010); + pub const ADOBERGB_LINEAR_EXT: Self = Self(1_000_104_011); + pub const ADOBERGB_NONLINEAR_EXT: Self = Self(1_000_104_012); + pub const PASS_THROUGH_EXT: Self = Self(1_000_104_013); + pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = Self(1_000_104_014); +} +impl ExtHdrMetadataFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_hdr_metadata\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetHdrMetadataEXT = unsafe extern "system" fn( + device: Device, + swapchain_count: u32, + p_swapchains: *const SwapchainKHR, + p_metadata: *const HdrMetadataEXT, +); +#[derive(Clone)] +pub struct ExtHdrMetadataFn { + pub set_hdr_metadata_ext: PFN_vkSetHdrMetadataEXT, +} +unsafe impl Send for ExtHdrMetadataFn {} +unsafe impl Sync for ExtHdrMetadataFn {} +impl ExtHdrMetadataFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_hdr_metadata_ext: unsafe { + unsafe extern "system" fn set_hdr_metadata_ext( + _device: Device, + _swapchain_count: u32, + _p_swapchains: *const SwapchainKHR, + _p_metadata: *const HdrMetadataEXT, + ) { + panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetHdrMetadataEXT\0"); + let val = _f(cname); + if val.is_null() { + set_hdr_metadata_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_hdr_metadata'"] +impl StructureType { + pub const HDR_METADATA_EXT: Self = Self(1_000_105_000); +} +impl ImgExtension107Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_107\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ImgExtension107Fn {} +unsafe impl Send for ImgExtension107Fn {} +unsafe impl Sync for ImgExtension107Fn {} +impl ImgExtension107Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ImgExtension108Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_108\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ImgExtension108Fn {} +unsafe impl Send for ImgExtension108Fn {} +unsafe impl Sync for ImgExtension108Fn {} +impl ImgExtension108Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrImagelessFramebufferFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_imageless_framebuffer\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrImagelessFramebufferFn {} +unsafe impl Send for KhrImagelessFramebufferFn {} +unsafe impl Sync for KhrImagelessFramebufferFn {} +impl KhrImagelessFramebufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"] +impl FramebufferCreateFlags { + pub const IMAGELESS_KHR: Self = Self::IMAGELESS; +} +#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: Self = + Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; + pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: Self = Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; + pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: Self = Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO; +} +impl KhrCreateRenderpass2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_create_renderpass2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRenderPass2 = unsafe extern "system" fn( + device: Device, + p_create_info: *const RenderPassCreateInfo2, + p_allocator: *const AllocationCallbacks, + p_render_pass: *mut RenderPass, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginRenderPass2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_render_pass_begin: *const RenderPassBeginInfo, + p_subpass_begin_info: *const SubpassBeginInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdNextSubpass2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_subpass_begin_info: *const SubpassBeginInfo, + p_subpass_end_info: *const SubpassEndInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndRenderPass2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_subpass_end_info: *const SubpassEndInfo, +); +#[derive(Clone)] +pub struct KhrCreateRenderpass2Fn { + pub create_render_pass2_khr: PFN_vkCreateRenderPass2, + pub cmd_begin_render_pass2_khr: PFN_vkCmdBeginRenderPass2, + pub cmd_next_subpass2_khr: PFN_vkCmdNextSubpass2, + pub cmd_end_render_pass2_khr: PFN_vkCmdEndRenderPass2, +} +unsafe impl Send for KhrCreateRenderpass2Fn {} +unsafe impl Sync for KhrCreateRenderpass2Fn {} +impl KhrCreateRenderpass2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_render_pass2_khr: unsafe { + unsafe extern "system" fn create_render_pass2_khr( + _device: Device, + _p_create_info: *const RenderPassCreateInfo2, + _p_allocator: *const AllocationCallbacks, + _p_render_pass: *mut RenderPass, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_render_pass2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2KHR\0"); + let val = _f(cname); + if val.is_null() { + create_render_pass2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_render_pass2_khr: unsafe { + unsafe extern "system" fn cmd_begin_render_pass2_khr( + _command_buffer: CommandBuffer, + _p_render_pass_begin: *const RenderPassBeginInfo, + _p_subpass_begin_info: *const SubpassBeginInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_render_pass2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_render_pass2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_next_subpass2_khr: unsafe { + unsafe extern "system" fn cmd_next_subpass2_khr( + _command_buffer: CommandBuffer, + _p_subpass_begin_info: *const SubpassBeginInfo, + _p_subpass_end_info: *const SubpassEndInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_next_subpass2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_next_subpass2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_render_pass2_khr: unsafe { + unsafe extern "system" fn cmd_end_render_pass2_khr( + _command_buffer: CommandBuffer, + _p_subpass_end_info: *const SubpassEndInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_render_pass2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_render_pass2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_create_renderpass2'"] +impl StructureType { + pub const ATTACHMENT_DESCRIPTION_2_KHR: Self = Self::ATTACHMENT_DESCRIPTION_2; + pub const ATTACHMENT_REFERENCE_2_KHR: Self = Self::ATTACHMENT_REFERENCE_2; + pub const SUBPASS_DESCRIPTION_2_KHR: Self = Self::SUBPASS_DESCRIPTION_2; + pub const SUBPASS_DEPENDENCY_2_KHR: Self = Self::SUBPASS_DEPENDENCY_2; + pub const RENDER_PASS_CREATE_INFO_2_KHR: Self = Self::RENDER_PASS_CREATE_INFO_2; + pub const SUBPASS_BEGIN_INFO_KHR: Self = Self::SUBPASS_BEGIN_INFO; + pub const SUBPASS_END_INFO_KHR: Self = Self::SUBPASS_END_INFO; +} +impl ImgExtension111Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_111\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ImgExtension111Fn {} +unsafe impl Send for ImgExtension111Fn {} +unsafe impl Sync for ImgExtension111Fn {} +impl ImgExtension111Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSharedPresentableImageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shared_presentable_image\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainStatusKHR = + unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; +#[derive(Clone)] +pub struct KhrSharedPresentableImageFn { + pub get_swapchain_status_khr: PFN_vkGetSwapchainStatusKHR, +} +unsafe impl Send for KhrSharedPresentableImageFn {} +unsafe impl Sync for KhrSharedPresentableImageFn {} +impl KhrSharedPresentableImageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_swapchain_status_khr: unsafe { + unsafe extern "system" fn get_swapchain_status_khr( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_status_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainStatusKHR\0"); + let val = _f(cname); + if val.is_null() { + get_swapchain_status_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_shared_presentable_image'"] +impl ImageLayout { + pub const SHARED_PRESENT_KHR: Self = Self(1_000_111_000); +} +#[doc = "Generated from 'VK_KHR_shared_presentable_image'"] +impl PresentModeKHR { + pub const SHARED_DEMAND_REFRESH: Self = Self(1_000_111_000); + pub const SHARED_CONTINUOUS_REFRESH: Self = Self(1_000_111_001); +} +#[doc = "Generated from 'VK_KHR_shared_presentable_image'"] +impl StructureType { + pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = Self(1_000_111_000); +} +impl KhrExternalFenceCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_capabilities\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceExternalFenceProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + p_external_fence_properties: *mut ExternalFenceProperties, +); +#[derive(Clone)] +pub struct KhrExternalFenceCapabilitiesFn { + pub get_physical_device_external_fence_properties_khr: + PFN_vkGetPhysicalDeviceExternalFenceProperties, +} +unsafe impl Send for KhrExternalFenceCapabilitiesFn {} +unsafe impl Sync for KhrExternalFenceCapabilitiesFn {} +impl KhrExternalFenceCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_external_fence_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_external_fence_properties_khr( + _physical_device: PhysicalDevice, + _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + _p_external_fence_properties: *mut ExternalFenceProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_fence_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalFencePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_fence_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"] +impl ExternalFenceFeatureFlags { + pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE; + pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE; +} +#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"] +impl ExternalFenceHandleTypeFlags { + pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD; + pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32; + pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT; + pub const SYNC_FD_KHR: Self = Self::SYNC_FD; +} +#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: Self = + Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; + pub const EXTERNAL_FENCE_PROPERTIES_KHR: Self = Self::EXTERNAL_FENCE_PROPERTIES; +} +impl KhrExternalFenceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrExternalFenceFn {} +unsafe impl Send for KhrExternalFenceFn {} +unsafe impl Sync for KhrExternalFenceFn {} +impl KhrExternalFenceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_external_fence'"] +impl FenceImportFlags { + pub const TEMPORARY_KHR: Self = Self::TEMPORARY; +} +#[doc = "Generated from 'VK_KHR_external_fence'"] +impl StructureType { + pub const EXPORT_FENCE_CREATE_INFO_KHR: Self = Self::EXPORT_FENCE_CREATE_INFO; +} +impl KhrExternalFenceWin32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_win32\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportFenceWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetFenceWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalFenceWin32Fn { + pub import_fence_win32_handle_khr: PFN_vkImportFenceWin32HandleKHR, + pub get_fence_win32_handle_khr: PFN_vkGetFenceWin32HandleKHR, +} +unsafe impl Send for KhrExternalFenceWin32Fn {} +unsafe impl Sync for KhrExternalFenceWin32Fn {} +impl KhrExternalFenceWin32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_fence_win32_handle_khr: unsafe { + unsafe extern "system" fn import_fence_win32_handle_khr( + _device: Device, + _p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_fence_win32_handle_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkImportFenceWin32HandleKHR\0", + ); + let val = _f(cname); + if val.is_null() { + import_fence_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + get_fence_win32_handle_khr: unsafe { + unsafe extern "system" fn get_fence_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_fence_win32_handle_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceWin32HandleKHR\0"); + let val = _f(cname); + if val.is_null() { + get_fence_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_fence_win32'"] +impl StructureType { + pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_000); + pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_001); + pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_002); +} +impl KhrExternalFenceFdFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_fd\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportFenceFdKHR = unsafe extern "system" fn( + device: Device, + p_import_fence_fd_info: *const ImportFenceFdInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetFenceFdKHR = unsafe extern "system" fn( + device: Device, + p_get_fd_info: *const FenceGetFdInfoKHR, + p_fd: *mut c_int, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalFenceFdFn { + pub import_fence_fd_khr: PFN_vkImportFenceFdKHR, + pub get_fence_fd_khr: PFN_vkGetFenceFdKHR, +} +unsafe impl Send for KhrExternalFenceFdFn {} +unsafe impl Sync for KhrExternalFenceFdFn {} +impl KhrExternalFenceFdFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_fence_fd_khr: unsafe { + unsafe extern "system" fn import_fence_fd_khr( + _device: Device, + _p_import_fence_fd_info: *const ImportFenceFdInfoKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(import_fence_fd_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkImportFenceFdKHR\0"); + let val = _f(cname); + if val.is_null() { + import_fence_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + get_fence_fd_khr: unsafe { + unsafe extern "system" fn get_fence_fd_khr( + _device: Device, + _p_get_fd_info: *const FenceGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_fence_fd_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceFdKHR\0"); + let val = _f(cname); + if val.is_null() { + get_fence_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_fence_fd'"] +impl StructureType { + pub const IMPORT_FENCE_FD_INFO_KHR: Self = Self(1_000_115_000); + pub const FENCE_GET_FD_INFO_KHR: Self = Self(1_000_115_001); +} +impl KhrPerformanceQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_performance_query\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + p_counter_count: *mut u32, + p_counters: *mut PerformanceCounterKHR, + p_counter_descriptions: *mut PerformanceCounterDescriptionKHR, + ) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR, + p_num_passes: *mut u32, + ); +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireProfilingLockKHR = + unsafe extern "system" fn(device: Device, p_info: *const AcquireProfilingLockInfoKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseProfilingLockKHR = unsafe extern "system" fn(device: Device); +#[derive(Clone)] +pub struct KhrPerformanceQueryFn { + pub enumerate_physical_device_queue_family_performance_query_counters_khr: + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, + pub get_physical_device_queue_family_performance_query_passes_khr: + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, + pub acquire_profiling_lock_khr: PFN_vkAcquireProfilingLockKHR, + pub release_profiling_lock_khr: PFN_vkReleaseProfilingLockKHR, +} +unsafe impl Send for KhrPerformanceQueryFn {} +unsafe impl Sync for KhrPerformanceQueryFn {} +impl KhrPerformanceQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + enumerate_physical_device_queue_family_performance_query_counters_khr: unsafe { + unsafe extern "system" fn enumerate_physical_device_queue_family_performance_query_counters_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _p_counter_count: *mut u32, + _p_counters: *mut PerformanceCounterKHR, + _p_counter_descriptions: *mut PerformanceCounterDescriptionKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!( + enumerate_physical_device_queue_family_performance_query_counters_khr + ) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_physical_device_queue_family_performance_query_counters_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_queue_family_performance_query_passes_khr: unsafe { + unsafe extern "system" fn get_physical_device_queue_family_performance_query_passes_khr( + _physical_device: PhysicalDevice, + _p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR, + _p_num_passes: *mut u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_queue_family_performance_query_passes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_queue_family_performance_query_passes_khr + } else { + ::std::mem::transmute(val) + } + }, + acquire_profiling_lock_khr: unsafe { + unsafe extern "system" fn acquire_profiling_lock_khr( + _device: Device, + _p_info: *const AcquireProfilingLockInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_profiling_lock_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireProfilingLockKHR\0"); + let val = _f(cname); + if val.is_null() { + acquire_profiling_lock_khr + } else { + ::std::mem::transmute(val) + } + }, + release_profiling_lock_khr: unsafe { + unsafe extern "system" fn release_profiling_lock_khr(_device: Device) { + panic!(concat!( + "Unable to load ", + stringify!(release_profiling_lock_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkReleaseProfilingLockKHR\0"); + let val = _f(cname); + if val.is_null() { + release_profiling_lock_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_performance_query'"] +impl QueryType { + pub const PERFORMANCE_QUERY_KHR: Self = Self(1_000_116_000); +} +#[doc = "Generated from 'VK_KHR_performance_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: Self = Self(1_000_116_000); + pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: Self = Self(1_000_116_001); + pub const QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: Self = Self(1_000_116_002); + pub const PERFORMANCE_QUERY_SUBMIT_INFO_KHR: Self = Self(1_000_116_003); + pub const ACQUIRE_PROFILING_LOCK_INFO_KHR: Self = Self(1_000_116_004); + pub const PERFORMANCE_COUNTER_KHR: Self = Self(1_000_116_005); + pub const PERFORMANCE_COUNTER_DESCRIPTION_KHR: Self = Self(1_000_116_006); +} +impl KhrMaintenance2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrMaintenance2Fn {} +unsafe impl Send for KhrMaintenance2Fn {} +unsafe impl Sync for KhrMaintenance2Fn {} +impl KhrMaintenance2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl ImageCreateFlags { + pub const BLOCK_TEXEL_VIEW_COMPATIBLE_KHR: Self = Self::BLOCK_TEXEL_VIEW_COMPATIBLE; + pub const EXTENDED_USAGE_KHR: Self = Self::EXTENDED_USAGE; +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl ImageLayout { + pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL; + pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: Self = + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL; +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl PointClippingBehavior { + pub const ALL_CLIP_PLANES_KHR: Self = Self::ALL_CLIP_PLANES; + pub const USER_CLIP_PLANES_ONLY_KHR: Self = Self::USER_CLIP_PLANES_ONLY; +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; + pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: Self = + Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; + pub const IMAGE_VIEW_USAGE_CREATE_INFO_KHR: Self = Self::IMAGE_VIEW_USAGE_CREATE_INFO; + pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: Self = + Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl TessellationDomainOrigin { + pub const UPPER_LEFT_KHR: Self = Self::UPPER_LEFT; + pub const LOWER_LEFT_KHR: Self = Self::LOWER_LEFT; +} +impl KhrExtension119Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_119\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension119Fn {} +unsafe impl Send for KhrExtension119Fn {} +unsafe impl Sync for KhrExtension119Fn {} +impl KhrExtension119Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrGetSurfaceCapabilities2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_surface_capabilities2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_capabilities: *mut SurfaceCapabilities2KHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_format_count: *mut u32, + p_surface_formats: *mut SurfaceFormat2KHR, +) -> Result; +#[derive(Clone)] +pub struct KhrGetSurfaceCapabilities2Fn { + pub get_physical_device_surface_capabilities2_khr: + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR, + pub get_physical_device_surface_formats2_khr: PFN_vkGetPhysicalDeviceSurfaceFormats2KHR, +} +unsafe impl Send for KhrGetSurfaceCapabilities2Fn {} +unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {} +impl KhrGetSurfaceCapabilities2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_surface_capabilities2_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_capabilities2_khr( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_surface_capabilities: *mut SurfaceCapabilities2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceCapabilities2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_capabilities2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_formats2_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_formats2_khr( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_surface_format_count: *mut u32, + _p_surface_formats: *mut SurfaceFormat2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_formats2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceFormats2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_formats2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_get_surface_capabilities2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = Self(1_000_119_000); + pub const SURFACE_CAPABILITIES_2_KHR: Self = Self(1_000_119_001); + pub const SURFACE_FORMAT_2_KHR: Self = Self(1_000_119_002); +} +impl KhrVariablePointersFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_variable_pointers\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrVariablePointersFn {} +unsafe impl Send for KhrVariablePointersFn {} +unsafe impl Sync for KhrVariablePointersFn {} +impl KhrVariablePointersFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_variable_pointers'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR; +} +impl KhrGetDisplayProperties2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_display_properties2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayProperties2KHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPlaneProperties2KHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *mut u32, + p_properties: *mut DisplayModeProperties2KHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_display_plane_info: *const DisplayPlaneInfo2KHR, + p_capabilities: *mut DisplayPlaneCapabilities2KHR, +) -> Result; +#[derive(Clone)] +pub struct KhrGetDisplayProperties2Fn { + pub get_physical_device_display_properties2_khr: PFN_vkGetPhysicalDeviceDisplayProperties2KHR, + pub get_physical_device_display_plane_properties2_khr: + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, + pub get_display_mode_properties2_khr: PFN_vkGetDisplayModeProperties2KHR, + pub get_display_plane_capabilities2_khr: PFN_vkGetDisplayPlaneCapabilities2KHR, +} +unsafe impl Send for KhrGetDisplayProperties2Fn {} +unsafe impl Sync for KhrGetDisplayProperties2Fn {} +impl KhrGetDisplayProperties2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_display_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_display_properties2_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDisplayProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_display_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_display_plane_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_display_plane_properties2_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPlaneProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_plane_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDisplayPlaneProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_display_plane_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_mode_properties2_khr: unsafe { + unsafe extern "system" fn get_display_mode_properties2_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_property_count: *mut u32, + _p_properties: *mut DisplayModeProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_mode_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayModeProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_mode_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_plane_capabilities2_khr: unsafe { + unsafe extern "system" fn get_display_plane_capabilities2_khr( + _physical_device: PhysicalDevice, + _p_display_plane_info: *const DisplayPlaneInfo2KHR, + _p_capabilities: *mut DisplayPlaneCapabilities2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_capabilities2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayPlaneCapabilities2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_plane_capabilities2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_get_display_properties2'"] +impl StructureType { + pub const DISPLAY_PROPERTIES_2_KHR: Self = Self(1_000_121_000); + pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = Self(1_000_121_001); + pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = Self(1_000_121_002); + pub const DISPLAY_PLANE_INFO_2_KHR: Self = Self(1_000_121_003); + pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = Self(1_000_121_004); +} +impl MvkIosSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_ios_surface\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateIOSSurfaceMVK = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct MvkIosSurfaceFn { + pub create_ios_surface_mvk: PFN_vkCreateIOSSurfaceMVK, +} +unsafe impl Send for MvkIosSurfaceFn {} +unsafe impl Sync for MvkIosSurfaceFn {} +impl MvkIosSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_ios_surface_mvk: unsafe { + unsafe extern "system" fn create_ios_surface_mvk( + _instance: Instance, + _p_create_info: *const IOSSurfaceCreateInfoMVK, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ios_surface_mvk) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateIOSSurfaceMVK\0"); + let val = _f(cname); + if val.is_null() { + create_ios_surface_mvk + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_MVK_ios_surface'"] +impl StructureType { + pub const IOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_122_000); +} +impl MvkMacosSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_macos_surface\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateMacOSSurfaceMVK = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct MvkMacosSurfaceFn { + pub create_mac_os_surface_mvk: PFN_vkCreateMacOSSurfaceMVK, +} +unsafe impl Send for MvkMacosSurfaceFn {} +unsafe impl Sync for MvkMacosSurfaceFn {} +impl MvkMacosSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_mac_os_surface_mvk: unsafe { + unsafe extern "system" fn create_mac_os_surface_mvk( + _instance: Instance, + _p_create_info: *const MacOSSurfaceCreateInfoMVK, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_mac_os_surface_mvk) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMacOSSurfaceMVK\0"); + let val = _f(cname); + if val.is_null() { + create_mac_os_surface_mvk + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_MVK_macos_surface'"] +impl StructureType { + pub const MACOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_123_000); +} +impl MvkMoltenvkFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_moltenvk\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct MvkMoltenvkFn {} +unsafe impl Send for MvkMoltenvkFn {} +unsafe impl Sync for MvkMoltenvkFn {} +impl MvkMoltenvkFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExternalMemoryDmaBufFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_dma_buf\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtExternalMemoryDmaBufFn {} +unsafe impl Send for ExtExternalMemoryDmaBufFn {} +unsafe impl Sync for ExtExternalMemoryDmaBufFn {} +impl ExtExternalMemoryDmaBufFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_external_memory_dma_buf'"] +impl ExternalMemoryHandleTypeFlags { + pub const DMA_BUF_EXT: Self = Self(0b10_0000_0000); +} +impl ExtQueueFamilyForeignFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_queue_family_foreign\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtQueueFamilyForeignFn {} +unsafe impl Send for ExtQueueFamilyForeignFn {} +unsafe impl Sync for ExtQueueFamilyForeignFn {} +impl ExtQueueFamilyForeignFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrDedicatedAllocationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dedicated_allocation\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct KhrDedicatedAllocationFn {} +unsafe impl Send for KhrDedicatedAllocationFn {} +unsafe impl Sync for KhrDedicatedAllocationFn {} +impl KhrDedicatedAllocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_dedicated_allocation'"] +impl StructureType { + pub const MEMORY_DEDICATED_REQUIREMENTS_KHR: Self = Self::MEMORY_DEDICATED_REQUIREMENTS; + pub const MEMORY_DEDICATED_ALLOCATE_INFO_KHR: Self = Self::MEMORY_DEDICATED_ALLOCATE_INFO; +} +impl ExtDebugUtilsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_utils\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetDebugUtilsObjectNameEXT = unsafe extern "system" fn( + device: Device, + p_name_info: *const DebugUtilsObjectNameInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetDebugUtilsObjectTagEXT = unsafe extern "system" fn( + device: Device, + p_tag_info: *const DebugUtilsObjectTagInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueBeginDebugUtilsLabelEXT = + unsafe extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueEndDebugUtilsLabelEXT = unsafe extern "system" fn(queue: Queue); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueInsertDebugUtilsLabelEXT = + unsafe extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginDebugUtilsLabelEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndDebugUtilsLabelEXT = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdInsertDebugUtilsLabelEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDebugUtilsMessengerEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_messenger: *mut DebugUtilsMessengerEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDebugUtilsMessengerEXT = unsafe extern "system" fn( + instance: Instance, + messenger: DebugUtilsMessengerEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkSubmitDebugUtilsMessageEXT = unsafe extern "system" fn( + instance: Instance, + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_types: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, +); +#[derive(Clone)] +pub struct ExtDebugUtilsFn { + pub set_debug_utils_object_name_ext: PFN_vkSetDebugUtilsObjectNameEXT, + pub set_debug_utils_object_tag_ext: PFN_vkSetDebugUtilsObjectTagEXT, + pub queue_begin_debug_utils_label_ext: PFN_vkQueueBeginDebugUtilsLabelEXT, + pub queue_end_debug_utils_label_ext: PFN_vkQueueEndDebugUtilsLabelEXT, + pub queue_insert_debug_utils_label_ext: PFN_vkQueueInsertDebugUtilsLabelEXT, + pub cmd_begin_debug_utils_label_ext: PFN_vkCmdBeginDebugUtilsLabelEXT, + pub cmd_end_debug_utils_label_ext: PFN_vkCmdEndDebugUtilsLabelEXT, + pub cmd_insert_debug_utils_label_ext: PFN_vkCmdInsertDebugUtilsLabelEXT, + pub create_debug_utils_messenger_ext: PFN_vkCreateDebugUtilsMessengerEXT, + pub destroy_debug_utils_messenger_ext: PFN_vkDestroyDebugUtilsMessengerEXT, + pub submit_debug_utils_message_ext: PFN_vkSubmitDebugUtilsMessageEXT, +} +unsafe impl Send for ExtDebugUtilsFn {} +unsafe impl Sync for ExtDebugUtilsFn {} +impl ExtDebugUtilsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_debug_utils_object_name_ext: unsafe { + unsafe extern "system" fn set_debug_utils_object_name_ext( + _device: Device, + _p_name_info: *const DebugUtilsObjectNameInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_debug_utils_object_name_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetDebugUtilsObjectNameEXT\0", + ); + let val = _f(cname); + if val.is_null() { + set_debug_utils_object_name_ext + } else { + ::std::mem::transmute(val) + } + }, + set_debug_utils_object_tag_ext: unsafe { + unsafe extern "system" fn set_debug_utils_object_tag_ext( + _device: Device, + _p_tag_info: *const DebugUtilsObjectTagInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_debug_utils_object_tag_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetDebugUtilsObjectTagEXT\0", + ); + let val = _f(cname); + if val.is_null() { + set_debug_utils_object_tag_ext + } else { + ::std::mem::transmute(val) + } + }, + queue_begin_debug_utils_label_ext: unsafe { + unsafe extern "system" fn queue_begin_debug_utils_label_ext( + _queue: Queue, + _p_label_info: *const DebugUtilsLabelEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(queue_begin_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueBeginDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + queue_begin_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + queue_end_debug_utils_label_ext: unsafe { + unsafe extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) { + panic!(concat!( + "Unable to load ", + stringify!(queue_end_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueEndDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + queue_end_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + queue_insert_debug_utils_label_ext: unsafe { + unsafe extern "system" fn queue_insert_debug_utils_label_ext( + _queue: Queue, + _p_label_info: *const DebugUtilsLabelEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(queue_insert_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueInsertDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + queue_insert_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_debug_utils_label_ext: unsafe { + unsafe extern "system" fn cmd_begin_debug_utils_label_ext( + _command_buffer: CommandBuffer, + _p_label_info: *const DebugUtilsLabelEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBeginDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_begin_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_debug_utils_label_ext: unsafe { + unsafe extern "system" fn cmd_end_debug_utils_label_ext( + _command_buffer: CommandBuffer, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdEndDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_end_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_insert_debug_utils_label_ext: unsafe { + unsafe extern "system" fn cmd_insert_debug_utils_label_ext( + _command_buffer: CommandBuffer, + _p_label_info: *const DebugUtilsLabelEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_insert_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdInsertDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_insert_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + create_debug_utils_messenger_ext: unsafe { + unsafe extern "system" fn create_debug_utils_messenger_ext( + _instance: Instance, + _p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_messenger: *mut DebugUtilsMessengerEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_debug_utils_messenger_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDebugUtilsMessengerEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_debug_utils_messenger_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_debug_utils_messenger_ext: unsafe { + unsafe extern "system" fn destroy_debug_utils_messenger_ext( + _instance: Instance, + _messenger: DebugUtilsMessengerEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_debug_utils_messenger_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDebugUtilsMessengerEXT\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_debug_utils_messenger_ext + } else { + ::std::mem::transmute(val) + } + }, + submit_debug_utils_message_ext: unsafe { + unsafe extern "system" fn submit_debug_utils_message_ext( + _instance: Instance, + _message_severity: DebugUtilsMessageSeverityFlagsEXT, + _message_types: DebugUtilsMessageTypeFlagsEXT, + _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(submit_debug_utils_message_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSubmitDebugUtilsMessageEXT\0", + ); + let val = _f(cname); + if val.is_null() { + submit_debug_utils_message_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_debug_utils'"] +impl ObjectType { + pub const DEBUG_UTILS_MESSENGER_EXT: Self = Self(1_000_128_000); +} +#[doc = "Generated from 'VK_EXT_debug_utils'"] +impl StructureType { + pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = Self(1_000_128_000); + pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = Self(1_000_128_001); + pub const DEBUG_UTILS_LABEL_EXT: Self = Self(1_000_128_002); + pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = Self(1_000_128_003); + pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = Self(1_000_128_004); +} +impl AndroidExternalMemoryAndroidHardwareBufferFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_ANDROID_external_memory_android_hardware_buffer\0", + ) + } + } + pub const SPEC_VERSION: u32 = 5u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetAndroidHardwareBufferPropertiesANDROID = unsafe extern "system" fn( + device: Device, + buffer: *const AHardwareBuffer, + p_properties: *mut AndroidHardwareBufferPropertiesANDROID, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryAndroidHardwareBufferANDROID = unsafe extern "system" fn( + device: Device, + p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + p_buffer: *mut *mut AHardwareBuffer, +) -> Result; +#[derive(Clone)] +pub struct AndroidExternalMemoryAndroidHardwareBufferFn { + pub get_android_hardware_buffer_properties_android: + PFN_vkGetAndroidHardwareBufferPropertiesANDROID, + pub get_memory_android_hardware_buffer_android: PFN_vkGetMemoryAndroidHardwareBufferANDROID, +} +unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {} +unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {} +impl AndroidExternalMemoryAndroidHardwareBufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_android_hardware_buffer_properties_android: unsafe { + unsafe extern "system" fn get_android_hardware_buffer_properties_android( + _device: Device, + _buffer: *const AHardwareBuffer, + _p_properties: *mut AndroidHardwareBufferPropertiesANDROID, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_android_hardware_buffer_properties_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAndroidHardwareBufferPropertiesANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + get_android_hardware_buffer_properties_android + } else { + ::std::mem::transmute(val) + } + }, + get_memory_android_hardware_buffer_android: unsafe { + unsafe extern "system" fn get_memory_android_hardware_buffer_android( + _device: Device, + _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + _p_buffer: *mut *mut AHardwareBuffer, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_android_hardware_buffer_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryAndroidHardwareBufferANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_android_hardware_buffer_android + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"] +impl ExternalMemoryHandleTypeFlags { + pub const ANDROID_HARDWARE_BUFFER_ANDROID: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"] +impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = Self(1_000_129_000); + pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = Self(1_000_129_001); + pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = Self(1_000_129_002); + pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_003); + pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_004); + pub const EXTERNAL_FORMAT_ANDROID: Self = Self(1_000_129_005); + pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: Self = Self(1_000_129_006); +} +impl ExtSamplerFilterMinmaxFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sampler_filter_minmax\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtSamplerFilterMinmaxFn {} +unsafe impl Send for ExtSamplerFilterMinmaxFn {} +unsafe impl Sync for ExtSamplerFilterMinmaxFn {} +impl ExtSamplerFilterMinmaxFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_MINMAX_EXT: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX; +} +#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"] +impl SamplerReductionMode { + pub const WEIGHTED_AVERAGE_EXT: Self = Self::WEIGHTED_AVERAGE; + pub const MIN_EXT: Self = Self::MIN; + pub const MAX_EXT: Self = Self::MAX; +} +#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; + pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self = + Self::SAMPLER_REDUCTION_MODE_CREATE_INFO; +} +impl KhrStorageBufferStorageClassFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_storage_buffer_storage_class\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrStorageBufferStorageClassFn {} +unsafe impl Send for KhrStorageBufferStorageClassFn {} +unsafe impl Sync for KhrStorageBufferStorageClassFn {} +impl KhrStorageBufferStorageClassFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdGpuShaderInt16Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_int16\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct AmdGpuShaderInt16Fn {} +unsafe impl Send for AmdGpuShaderInt16Fn {} +unsafe impl Sync for AmdGpuShaderInt16Fn {} +impl AmdGpuShaderInt16Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension134Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_134\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension134Fn {} +unsafe impl Send for AmdExtension134Fn {} +unsafe impl Sync for AmdExtension134Fn {} +impl AmdExtension134Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension135Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_135\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension135Fn {} +unsafe impl Send for AmdExtension135Fn {} +unsafe impl Sync for AmdExtension135Fn {} +impl AmdExtension135Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_extension_135'"] +impl BufferUsageFlags { + pub const RESERVED_25_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +impl AmdExtension136Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_136\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension136Fn {} +unsafe impl Send for AmdExtension136Fn {} +unsafe impl Sync for AmdExtension136Fn {} +impl AmdExtension136Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdMixedAttachmentSamplesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_mixed_attachment_samples\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdMixedAttachmentSamplesFn {} +unsafe impl Send for AmdMixedAttachmentSamplesFn {} +unsafe impl Sync for AmdMixedAttachmentSamplesFn {} +impl AmdMixedAttachmentSamplesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderFragmentMaskFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_fragment_mask\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderFragmentMaskFn {} +unsafe impl Send for AmdShaderFragmentMaskFn {} +unsafe impl Sync for AmdShaderFragmentMaskFn {} +impl AmdShaderFragmentMaskFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtInlineUniformBlockFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_inline_uniform_block\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtInlineUniformBlockFn {} +unsafe impl Send for ExtInlineUniformBlockFn {} +unsafe impl Sync for ExtInlineUniformBlockFn {} +impl ExtInlineUniformBlockFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_inline_uniform_block'"] +impl DescriptorType { + pub const INLINE_UNIFORM_BLOCK_EXT: Self = Self::INLINE_UNIFORM_BLOCK; +} +#[doc = "Generated from 'VK_EXT_inline_uniform_block'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; + pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: Self = + Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; + pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: Self = + Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; +} +impl AmdExtension140Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_140\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension140Fn {} +unsafe impl Send for AmdExtension140Fn {} +unsafe impl Sync for AmdExtension140Fn {} +impl AmdExtension140Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderStencilExportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_stencil_export\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderStencilExportFn {} +unsafe impl Send for ExtShaderStencilExportFn {} +unsafe impl Sync for ExtShaderStencilExportFn {} +impl ExtShaderStencilExportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension142Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_142\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension142Fn {} +unsafe impl Send for AmdExtension142Fn {} +unsafe impl Sync for AmdExtension142Fn {} +impl AmdExtension142Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension143Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_143\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension143Fn {} +unsafe impl Send for AmdExtension143Fn {} +unsafe impl Sync for AmdExtension143Fn {} +impl AmdExtension143Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtSampleLocationsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sample_locations\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetSampleLocationsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_sample_locations_info: *const SampleLocationsInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + samples: SampleCountFlags, + p_multisample_properties: *mut MultisamplePropertiesEXT, +); +#[derive(Clone)] +pub struct ExtSampleLocationsFn { + pub cmd_set_sample_locations_ext: PFN_vkCmdSetSampleLocationsEXT, + pub get_physical_device_multisample_properties_ext: + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT, +} +unsafe impl Send for ExtSampleLocationsFn {} +unsafe impl Sync for ExtSampleLocationsFn {} +impl ExtSampleLocationsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_sample_locations_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_locations_ext( + _command_buffer: CommandBuffer, + _p_sample_locations_info: *const SampleLocationsInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_locations_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetSampleLocationsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_locations_ext + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_multisample_properties_ext: unsafe { + unsafe extern "system" fn get_physical_device_multisample_properties_ext( + _physical_device: PhysicalDevice, + _samples: SampleCountFlags, + _p_multisample_properties: *mut MultisamplePropertiesEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_multisample_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceMultisamplePropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_multisample_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_sample_locations'"] +impl DynamicState { + pub const SAMPLE_LOCATIONS_EXT: Self = Self(1_000_143_000); +} +#[doc = "Generated from 'VK_EXT_sample_locations'"] +impl ImageCreateFlags { + pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_sample_locations'"] +impl StructureType { + pub const SAMPLE_LOCATIONS_INFO_EXT: Self = Self(1_000_143_000); + pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = Self(1_000_143_001); + pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = Self(1_000_143_002); + pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = Self(1_000_143_003); + pub const MULTISAMPLE_PROPERTIES_EXT: Self = Self(1_000_143_004); +} +impl KhrRelaxedBlockLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_relaxed_block_layout\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrRelaxedBlockLayoutFn {} +unsafe impl Send for KhrRelaxedBlockLayoutFn {} +unsafe impl Sync for KhrRelaxedBlockLayoutFn {} +impl KhrRelaxedBlockLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrGetMemoryRequirements2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_memory_requirements2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageMemoryRequirements2 = unsafe extern "system" fn( + device: Device, + p_info: *const ImageMemoryRequirementsInfo2, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferMemoryRequirements2 = unsafe extern "system" fn( + device: Device, + p_info: *const BufferMemoryRequirementsInfo2, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSparseMemoryRequirements2 = unsafe extern "system" fn( + device: Device, + p_info: *const ImageSparseMemoryRequirementsInfo2, + p_sparse_memory_requirement_count: *mut u32, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, +); +#[derive(Clone)] +pub struct KhrGetMemoryRequirements2Fn { + pub get_image_memory_requirements2_khr: PFN_vkGetImageMemoryRequirements2, + pub get_buffer_memory_requirements2_khr: PFN_vkGetBufferMemoryRequirements2, + pub get_image_sparse_memory_requirements2_khr: PFN_vkGetImageSparseMemoryRequirements2, +} +unsafe impl Send for KhrGetMemoryRequirements2Fn {} +unsafe impl Sync for KhrGetMemoryRequirements2Fn {} +impl KhrGetMemoryRequirements2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_image_memory_requirements2_khr: unsafe { + unsafe extern "system" fn get_image_memory_requirements2_khr( + _device: Device, + _p_info: *const ImageMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_memory_requirements2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageMemoryRequirements2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_memory_requirements2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_memory_requirements2_khr: unsafe { + unsafe extern "system" fn get_buffer_memory_requirements2_khr( + _device: Device, + _p_info: *const BufferMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_memory_requirements2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferMemoryRequirements2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_memory_requirements2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_image_sparse_memory_requirements2_khr: unsafe { + unsafe extern "system" fn get_image_sparse_memory_requirements2_khr( + _device: Device, + _p_info: *const ImageSparseMemoryRequirementsInfo2, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_sparse_memory_requirements2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSparseMemoryRequirements2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_sparse_memory_requirements2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_get_memory_requirements2'"] +impl StructureType { + pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2; + pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2; + pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = + Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; + pub const MEMORY_REQUIREMENTS_2_KHR: Self = Self::MEMORY_REQUIREMENTS_2; + pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: Self = + Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; +} +impl KhrImageFormatListFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_image_format_list\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrImageFormatListFn {} +unsafe impl Send for KhrImageFormatListFn {} +unsafe impl Sync for KhrImageFormatListFn {} +impl KhrImageFormatListFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_image_format_list'"] +impl StructureType { + pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = Self::IMAGE_FORMAT_LIST_CREATE_INFO; +} +impl ExtBlendOperationAdvancedFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_blend_operation_advanced\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtBlendOperationAdvancedFn {} +unsafe impl Send for ExtBlendOperationAdvancedFn {} +unsafe impl Sync for ExtBlendOperationAdvancedFn {} +impl ExtBlendOperationAdvancedFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"] +impl AccessFlags { + pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"] +impl BlendOp { + pub const ZERO_EXT: Self = Self(1_000_148_000); + pub const SRC_EXT: Self = Self(1_000_148_001); + pub const DST_EXT: Self = Self(1_000_148_002); + pub const SRC_OVER_EXT: Self = Self(1_000_148_003); + pub const DST_OVER_EXT: Self = Self(1_000_148_004); + pub const SRC_IN_EXT: Self = Self(1_000_148_005); + pub const DST_IN_EXT: Self = Self(1_000_148_006); + pub const SRC_OUT_EXT: Self = Self(1_000_148_007); + pub const DST_OUT_EXT: Self = Self(1_000_148_008); + pub const SRC_ATOP_EXT: Self = Self(1_000_148_009); + pub const DST_ATOP_EXT: Self = Self(1_000_148_010); + pub const XOR_EXT: Self = Self(1_000_148_011); + pub const MULTIPLY_EXT: Self = Self(1_000_148_012); + pub const SCREEN_EXT: Self = Self(1_000_148_013); + pub const OVERLAY_EXT: Self = Self(1_000_148_014); + pub const DARKEN_EXT: Self = Self(1_000_148_015); + pub const LIGHTEN_EXT: Self = Self(1_000_148_016); + pub const COLORDODGE_EXT: Self = Self(1_000_148_017); + pub const COLORBURN_EXT: Self = Self(1_000_148_018); + pub const HARDLIGHT_EXT: Self = Self(1_000_148_019); + pub const SOFTLIGHT_EXT: Self = Self(1_000_148_020); + pub const DIFFERENCE_EXT: Self = Self(1_000_148_021); + pub const EXCLUSION_EXT: Self = Self(1_000_148_022); + pub const INVERT_EXT: Self = Self(1_000_148_023); + pub const INVERT_RGB_EXT: Self = Self(1_000_148_024); + pub const LINEARDODGE_EXT: Self = Self(1_000_148_025); + pub const LINEARBURN_EXT: Self = Self(1_000_148_026); + pub const VIVIDLIGHT_EXT: Self = Self(1_000_148_027); + pub const LINEARLIGHT_EXT: Self = Self(1_000_148_028); + pub const PINLIGHT_EXT: Self = Self(1_000_148_029); + pub const HARDMIX_EXT: Self = Self(1_000_148_030); + pub const HSL_HUE_EXT: Self = Self(1_000_148_031); + pub const HSL_SATURATION_EXT: Self = Self(1_000_148_032); + pub const HSL_COLOR_EXT: Self = Self(1_000_148_033); + pub const HSL_LUMINOSITY_EXT: Self = Self(1_000_148_034); + pub const PLUS_EXT: Self = Self(1_000_148_035); + pub const PLUS_CLAMPED_EXT: Self = Self(1_000_148_036); + pub const PLUS_CLAMPED_ALPHA_EXT: Self = Self(1_000_148_037); + pub const PLUS_DARKER_EXT: Self = Self(1_000_148_038); + pub const MINUS_EXT: Self = Self(1_000_148_039); + pub const MINUS_CLAMPED_EXT: Self = Self(1_000_148_040); + pub const CONTRAST_EXT: Self = Self(1_000_148_041); + pub const INVERT_OVG_EXT: Self = Self(1_000_148_042); + pub const RED_EXT: Self = Self(1_000_148_043); + pub const GREEN_EXT: Self = Self(1_000_148_044); + pub const BLUE_EXT: Self = Self(1_000_148_045); +} +#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = Self(1_000_148_000); + pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = Self(1_000_148_001); + pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = Self(1_000_148_002); +} +impl NvFragmentCoverageToColorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_coverage_to_color\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvFragmentCoverageToColorFn {} +unsafe impl Send for NvFragmentCoverageToColorFn {} +unsafe impl Sync for NvFragmentCoverageToColorFn {} +impl NvFragmentCoverageToColorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_fragment_coverage_to_color'"] +impl StructureType { + pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = Self(1_000_149_000); +} +impl KhrAccelerationStructureFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_acceleration_structure\0") + } + } + pub const SPEC_VERSION: u32 = 13u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn( + device: Device, + p_create_info: *const AccelerationStructureCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_acceleration_structure: *mut AccelerationStructureKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyAccelerationStructureKHR = unsafe extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildAccelerationStructuresKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + p_indirect_device_addresses: *const DeviceAddress, + p_indirect_strides: *const u32, + pp_max_primitive_counts: *const *const u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBuildAccelerationStructuresKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyAccelerationStructureKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyAccelerationStructureInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyAccelerationStructureToMemoryInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMemoryToAccelerationStructureInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn( + device: Device, + acceleration_structure_count: u32, + p_acceleration_structures: *const AccelerationStructureKHR, + query_type: QueryType, + data_size: usize, + p_data: *mut c_void, + stride: usize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyAccelerationStructureKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyAccelerationStructureInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyAccelerationStructureToMemoryInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyMemoryToAccelerationStructureInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureDeviceAddressKHR = + unsafe extern "system" fn( + device: Device, + p_info: *const AccelerationStructureDeviceAddressInfoKHR, + ) -> DeviceAddress; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + acceleration_structure_count: u32, + p_acceleration_structures: *const AccelerationStructureKHR, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = unsafe extern "system" fn( + device: Device, + p_version_info: *const AccelerationStructureVersionInfoKHR, + p_compatibility: *mut AccelerationStructureCompatibilityKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureBuildSizesKHR = unsafe extern "system" fn( + device: Device, + build_type: AccelerationStructureBuildTypeKHR, + p_build_info: *const AccelerationStructureBuildGeometryInfoKHR, + p_max_primitive_counts: *const u32, + p_size_info: *mut AccelerationStructureBuildSizesInfoKHR, +); +#[derive(Clone)] +pub struct KhrAccelerationStructureFn { + pub create_acceleration_structure_khr: PFN_vkCreateAccelerationStructureKHR, + pub destroy_acceleration_structure_khr: PFN_vkDestroyAccelerationStructureKHR, + pub cmd_build_acceleration_structures_khr: PFN_vkCmdBuildAccelerationStructuresKHR, + pub cmd_build_acceleration_structures_indirect_khr: + PFN_vkCmdBuildAccelerationStructuresIndirectKHR, + pub build_acceleration_structures_khr: PFN_vkBuildAccelerationStructuresKHR, + pub copy_acceleration_structure_khr: PFN_vkCopyAccelerationStructureKHR, + pub copy_acceleration_structure_to_memory_khr: PFN_vkCopyAccelerationStructureToMemoryKHR, + pub copy_memory_to_acceleration_structure_khr: PFN_vkCopyMemoryToAccelerationStructureKHR, + pub write_acceleration_structures_properties_khr: + PFN_vkWriteAccelerationStructuresPropertiesKHR, + pub cmd_copy_acceleration_structure_khr: PFN_vkCmdCopyAccelerationStructureKHR, + pub cmd_copy_acceleration_structure_to_memory_khr: + PFN_vkCmdCopyAccelerationStructureToMemoryKHR, + pub cmd_copy_memory_to_acceleration_structure_khr: + PFN_vkCmdCopyMemoryToAccelerationStructureKHR, + pub get_acceleration_structure_device_address_khr: + PFN_vkGetAccelerationStructureDeviceAddressKHR, + pub cmd_write_acceleration_structures_properties_khr: + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR, + pub get_device_acceleration_structure_compatibility_khr: + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR, + pub get_acceleration_structure_build_sizes_khr: PFN_vkGetAccelerationStructureBuildSizesKHR, +} +unsafe impl Send for KhrAccelerationStructureFn {} +unsafe impl Sync for KhrAccelerationStructureFn {} +impl KhrAccelerationStructureFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_acceleration_structure_khr: unsafe { + unsafe extern "system" fn create_acceleration_structure_khr( + _device: Device, + _p_create_info: *const AccelerationStructureCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_acceleration_structure: *mut AccelerationStructureKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_acceleration_structure_khr: unsafe { + unsafe extern "system" fn destroy_acceleration_structure_khr( + _device: Device, + _acceleration_structure: AccelerationStructureKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_acceleration_structures_khr: unsafe { + unsafe extern "system" fn cmd_build_acceleration_structures_khr( + _command_buffer: CommandBuffer, + _info_count: u32, + _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_acceleration_structures_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBuildAccelerationStructuresKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_build_acceleration_structures_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_acceleration_structures_indirect_khr: unsafe { + unsafe extern "system" fn cmd_build_acceleration_structures_indirect_khr( + _command_buffer: CommandBuffer, + _info_count: u32, + _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + _p_indirect_device_addresses: *const DeviceAddress, + _p_indirect_strides: *const u32, + _pp_max_primitive_counts: *const *const u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_acceleration_structures_indirect_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBuildAccelerationStructuresIndirectKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_build_acceleration_structures_indirect_khr + } else { + ::std::mem::transmute(val) + } + }, + build_acceleration_structures_khr: unsafe { + unsafe extern "system" fn build_acceleration_structures_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _info_count: u32, + _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(build_acceleration_structures_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBuildAccelerationStructuresKHR\0", + ); + let val = _f(cname); + if val.is_null() { + build_acceleration_structures_khr + } else { + ::std::mem::transmute(val) + } + }, + copy_acceleration_structure_khr: unsafe { + unsafe extern "system" fn copy_acceleration_structure_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyAccelerationStructureInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCopyAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + copy_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + copy_acceleration_structure_to_memory_khr: unsafe { + unsafe extern "system" fn copy_acceleration_structure_to_memory_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyAccelerationStructureToMemoryInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_acceleration_structure_to_memory_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCopyAccelerationStructureToMemoryKHR\0", + ); + let val = _f(cname); + if val.is_null() { + copy_acceleration_structure_to_memory_khr + } else { + ::std::mem::transmute(val) + } + }, + copy_memory_to_acceleration_structure_khr: unsafe { + unsafe extern "system" fn copy_memory_to_acceleration_structure_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMemoryToAccelerationStructureInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_memory_to_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCopyMemoryToAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + copy_memory_to_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + write_acceleration_structures_properties_khr: unsafe { + unsafe extern "system" fn write_acceleration_structures_properties_khr( + _device: Device, + _acceleration_structure_count: u32, + _p_acceleration_structures: *const AccelerationStructureKHR, + _query_type: QueryType, + _data_size: usize, + _p_data: *mut c_void, + _stride: usize, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(write_acceleration_structures_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkWriteAccelerationStructuresPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + write_acceleration_structures_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_acceleration_structure_khr: unsafe { + unsafe extern "system" fn cmd_copy_acceleration_structure_khr( + _command_buffer: CommandBuffer, + _p_info: *const CopyAccelerationStructureInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_acceleration_structure_to_memory_khr: unsafe { + unsafe extern "system" fn cmd_copy_acceleration_structure_to_memory_khr( + _command_buffer: CommandBuffer, + _p_info: *const CopyAccelerationStructureToMemoryInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_acceleration_structure_to_memory_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyAccelerationStructureToMemoryKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_acceleration_structure_to_memory_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_memory_to_acceleration_structure_khr: unsafe { + unsafe extern "system" fn cmd_copy_memory_to_acceleration_structure_khr( + _command_buffer: CommandBuffer, + _p_info: *const CopyMemoryToAccelerationStructureInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_to_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMemoryToAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_to_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_device_address_khr: unsafe { + unsafe extern "system" fn get_acceleration_structure_device_address_khr( + _device: Device, + _p_info: *const AccelerationStructureDeviceAddressInfoKHR, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_device_address_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureDeviceAddressKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_device_address_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_acceleration_structures_properties_khr: unsafe { + unsafe extern "system" fn cmd_write_acceleration_structures_properties_khr( + _command_buffer: CommandBuffer, + _acceleration_structure_count: u32, + _p_acceleration_structures: *const AccelerationStructureKHR, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_acceleration_structures_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteAccelerationStructuresPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_acceleration_structures_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_acceleration_structure_compatibility_khr: unsafe { + unsafe extern "system" fn get_device_acceleration_structure_compatibility_khr( + _device: Device, + _p_version_info: *const AccelerationStructureVersionInfoKHR, + _p_compatibility: *mut AccelerationStructureCompatibilityKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_acceleration_structure_compatibility_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceAccelerationStructureCompatibilityKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_acceleration_structure_compatibility_khr + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_build_sizes_khr: unsafe { + unsafe extern "system" fn get_acceleration_structure_build_sizes_khr( + _device: Device, + _build_type: AccelerationStructureBuildTypeKHR, + _p_build_info: *const AccelerationStructureBuildGeometryInfoKHR, + _p_max_primitive_counts: *const u32, + _p_size_info: *mut AccelerationStructureBuildSizesInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_build_sizes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureBuildSizesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_build_sizes_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl AccessFlags { + pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl BufferUsageFlags { + pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR: Self = + Self(0b1000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_STORAGE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl DebugReportObjectTypeEXT { + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl DescriptorType { + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl FormatFeatureFlags { + pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl FormatFeatureFlags2 { + pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl IndexType { + pub const NONE_KHR: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl ObjectType { + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl PipelineStageFlags { + pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl QueryType { + pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1_000_150_000); + pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1_000_150_001); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl StructureType { + pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_007); + pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: Self = Self(1_000_150_000); + pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: Self = Self(1_000_150_002); + pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: Self = Self(1_000_150_003); + pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: Self = Self(1_000_150_004); + pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: Self = Self(1_000_150_005); + pub const ACCELERATION_STRUCTURE_GEOMETRY_KHR: Self = Self(1_000_150_006); + pub const ACCELERATION_STRUCTURE_VERSION_INFO_KHR: Self = Self(1_000_150_009); + pub const COPY_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_010); + pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: Self = Self(1_000_150_011); + pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_012); + pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: Self = Self(1_000_150_013); + pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: Self = Self(1_000_150_014); + pub const ACCELERATION_STRUCTURE_CREATE_INFO_KHR: Self = Self(1_000_150_017); + pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: Self = Self(1_000_150_020); +} +impl KhrRayTracingPipelineFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_pipeline\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + width: u32, + height: u32, + depth: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRayTracingPipelinesKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = + unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, + ) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysIndirectKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + indirect_device_address: DeviceAddress, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + group: u32, + group_shader: ShaderGroupShaderKHR, +) -> DeviceSize; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR = + unsafe extern "system" fn(command_buffer: CommandBuffer, pipeline_stack_size: u32); +#[derive(Clone)] +pub struct KhrRayTracingPipelineFn { + pub cmd_trace_rays_khr: PFN_vkCmdTraceRaysKHR, + pub create_ray_tracing_pipelines_khr: PFN_vkCreateRayTracingPipelinesKHR, + pub get_ray_tracing_shader_group_handles_khr: PFN_vkGetRayTracingShaderGroupHandlesKHR, + pub get_ray_tracing_capture_replay_shader_group_handles_khr: + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, + pub cmd_trace_rays_indirect_khr: PFN_vkCmdTraceRaysIndirectKHR, + pub get_ray_tracing_shader_group_stack_size_khr: PFN_vkGetRayTracingShaderGroupStackSizeKHR, + pub cmd_set_ray_tracing_pipeline_stack_size_khr: PFN_vkCmdSetRayTracingPipelineStackSizeKHR, +} +unsafe impl Send for KhrRayTracingPipelineFn {} +unsafe impl Sync for KhrRayTracingPipelineFn {} +impl KhrRayTracingPipelineFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_trace_rays_khr: unsafe { + unsafe extern "system" fn cmd_trace_rays_khr( + _command_buffer: CommandBuffer, + _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _width: u32, + _height: u32, + _depth: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_khr + } else { + ::std::mem::transmute(val) + } + }, + create_ray_tracing_pipelines_khr: unsafe { + unsafe extern "system" fn create_ray_tracing_pipelines_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const RayTracingPipelineCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ray_tracing_pipelines_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateRayTracingPipelinesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_ray_tracing_pipelines_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_handles_khr: unsafe { + unsafe extern "system" fn get_ray_tracing_shader_group_handles_khr( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_handles_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRayTracingShaderGroupHandlesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_ray_tracing_shader_group_handles_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_capture_replay_shader_group_handles_khr: unsafe { + unsafe extern "system" fn get_ray_tracing_capture_replay_shader_group_handles_khr( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_capture_replay_shader_group_handles_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_ray_tracing_capture_replay_shader_group_handles_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_trace_rays_indirect_khr: unsafe { + unsafe extern "system" fn cmd_trace_rays_indirect_khr( + _command_buffer: CommandBuffer, + _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _indirect_device_address: DeviceAddress, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_trace_rays_indirect_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysIndirectKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_indirect_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_stack_size_khr: unsafe { + unsafe extern "system" fn get_ray_tracing_shader_group_stack_size_khr( + _device: Device, + _pipeline: Pipeline, + _group: u32, + _group_shader: ShaderGroupShaderKHR, + ) -> DeviceSize { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_stack_size_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRayTracingShaderGroupStackSizeKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_ray_tracing_shader_group_stack_size_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_ray_tracing_pipeline_stack_size_khr: unsafe { + unsafe extern "system" fn cmd_set_ray_tracing_pipeline_stack_size_khr( + _command_buffer: CommandBuffer, + _pipeline_stack_size: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_ray_tracing_pipeline_stack_size_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRayTracingPipelineStackSizeKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_ray_tracing_pipeline_stack_size_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl BufferUsageFlags { + pub const SHADER_BINDING_TABLE_KHR: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl DynamicState { + pub const RAY_TRACING_PIPELINE_STACK_SIZE_KHR: Self = Self(1_000_347_000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl PipelineBindPoint { + pub const RAY_TRACING_KHR: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR: Self = Self(0b100_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR: Self = Self(0b1000_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_MISS_SHADERS_KHR: Self = Self(0b1_0000_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR: Self = Self(0b10_0000_0000_0000_0000); + pub const RAY_TRACING_SKIP_TRIANGLES_KHR: Self = Self(0b1_0000_0000_0000); + pub const RAY_TRACING_SKIP_AABBS_KHR: Self = Self(0b10_0000_0000_0000); + pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR: Self = + Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl PipelineStageFlags { + pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl ShaderStageFlags { + pub const RAYGEN_KHR: Self = Self(0b1_0000_0000); + pub const ANY_HIT_KHR: Self = Self(0b10_0000_0000); + pub const CLOSEST_HIT_KHR: Self = Self(0b100_0000_0000); + pub const MISS_KHR: Self = Self(0b1000_0000_0000); + pub const INTERSECTION_KHR: Self = Self(0b1_0000_0000_0000); + pub const CALLABLE_KHR: Self = Self(0b10_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: Self = Self(1_000_347_000); + pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: Self = Self(1_000_347_001); + pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1_000_150_015); + pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1_000_150_016); + pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1_000_150_018); +} +impl KhrRayQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_query\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrRayQueryFn {} +unsafe impl Send for KhrRayQueryFn {} +unsafe impl Sync for KhrRayQueryFn {} +impl KhrRayQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_ray_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: Self = Self(1_000_348_013); +} +impl NvExtension152Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_152\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension152Fn {} +unsafe impl Send for NvExtension152Fn {} +unsafe impl Sync for NvExtension152Fn {} +impl NvExtension152Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvFramebufferMixedSamplesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_framebuffer_mixed_samples\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvFramebufferMixedSamplesFn {} +unsafe impl Send for NvFramebufferMixedSamplesFn {} +unsafe impl Sync for NvFramebufferMixedSamplesFn {} +impl NvFramebufferMixedSamplesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_framebuffer_mixed_samples'"] +impl StructureType { + pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = Self(1_000_152_000); +} +impl NvFillRectangleFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fill_rectangle\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvFillRectangleFn {} +unsafe impl Send for NvFillRectangleFn {} +unsafe impl Sync for NvFillRectangleFn {} +impl NvFillRectangleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_fill_rectangle'"] +impl PolygonMode { + pub const FILL_RECTANGLE_NV: Self = Self(1_000_153_000); +} +impl NvShaderSmBuiltinsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_sm_builtins\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvShaderSmBuiltinsFn {} +unsafe impl Send for NvShaderSmBuiltinsFn {} +unsafe impl Sync for NvShaderSmBuiltinsFn {} +impl NvShaderSmBuiltinsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_shader_sm_builtins'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1_000_154_000); + pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: Self = Self(1_000_154_001); +} +impl ExtPostDepthCoverageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_post_depth_coverage\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPostDepthCoverageFn {} +unsafe impl Send for ExtPostDepthCoverageFn {} +unsafe impl Sync for ExtPostDepthCoverageFn {} +impl ExtPostDepthCoverageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSamplerYcbcrConversionFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_sampler_ycbcr_conversion\0") + } + } + pub const SPEC_VERSION: u32 = 14u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSamplerYcbcrConversion = unsafe extern "system" fn( + device: Device, + p_create_info: *const SamplerYcbcrConversionCreateInfo, + p_allocator: *const AllocationCallbacks, + p_ycbcr_conversion: *mut SamplerYcbcrConversion, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySamplerYcbcrConversion = unsafe extern "system" fn( + device: Device, + ycbcr_conversion: SamplerYcbcrConversion, + p_allocator: *const AllocationCallbacks, +); +#[derive(Clone)] +pub struct KhrSamplerYcbcrConversionFn { + pub create_sampler_ycbcr_conversion_khr: PFN_vkCreateSamplerYcbcrConversion, + pub destroy_sampler_ycbcr_conversion_khr: PFN_vkDestroySamplerYcbcrConversion, +} +unsafe impl Send for KhrSamplerYcbcrConversionFn {} +unsafe impl Sync for KhrSamplerYcbcrConversionFn {} +impl KhrSamplerYcbcrConversionFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_sampler_ycbcr_conversion_khr: unsafe { + unsafe extern "system" fn create_sampler_ycbcr_conversion_khr( + _device: Device, + _p_create_info: *const SamplerYcbcrConversionCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_ycbcr_conversion: *mut SamplerYcbcrConversion, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_sampler_ycbcr_conversion_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateSamplerYcbcrConversionKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_sampler_ycbcr_conversion_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_sampler_ycbcr_conversion_khr: unsafe { + unsafe extern "system" fn destroy_sampler_ycbcr_conversion_khr( + _device: Device, + _ycbcr_conversion: SamplerYcbcrConversion, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_sampler_ycbcr_conversion_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroySamplerYcbcrConversionKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_sampler_ycbcr_conversion_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl ChromaLocation { + pub const COSITED_EVEN_KHR: Self = Self::COSITED_EVEN; + pub const MIDPOINT_KHR: Self = Self::MIDPOINT; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl DebugReportObjectTypeEXT { + pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl Format { + pub const G8B8G8R8_422_UNORM_KHR: Self = Self::G8B8G8R8_422_UNORM; + pub const B8G8R8G8_422_UNORM_KHR: Self = Self::B8G8R8G8_422_UNORM; + pub const G8_B8_R8_3PLANE_420_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_420_UNORM; + pub const G8_B8R8_2PLANE_420_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_420_UNORM; + pub const G8_B8_R8_3PLANE_422_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_422_UNORM; + pub const G8_B8R8_2PLANE_422_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_422_UNORM; + pub const G8_B8_R8_3PLANE_444_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_444_UNORM; + pub const R10X6_UNORM_PACK16_KHR: Self = Self::R10X6_UNORM_PACK16; + pub const R10X6G10X6_UNORM_2PACK16_KHR: Self = Self::R10X6G10X6_UNORM_2PACK16; + pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: Self = + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16; + pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: Self = + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16; + pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: Self = + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; + pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16; + pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16; + pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16; + pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16; + pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16; + pub const R12X4_UNORM_PACK16_KHR: Self = Self::R12X4_UNORM_PACK16; + pub const R12X4G12X4_UNORM_2PACK16_KHR: Self = Self::R12X4G12X4_UNORM_2PACK16; + pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: Self = + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16; + pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: Self = + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16; + pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: Self = + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16; + pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16; + pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16; + pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16; + pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16; + pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16; + pub const G16B16G16R16_422_UNORM_KHR: Self = Self::G16B16G16R16_422_UNORM; + pub const B16G16R16G16_422_UNORM_KHR: Self = Self::B16G16R16G16_422_UNORM; + pub const G16_B16_R16_3PLANE_420_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_420_UNORM; + pub const G16_B16R16_2PLANE_420_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_420_UNORM; + pub const G16_B16_R16_3PLANE_422_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_422_UNORM; + pub const G16_B16R16_2PLANE_422_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_422_UNORM; + pub const G16_B16_R16_3PLANE_444_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_444_UNORM; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl FormatFeatureFlags { + pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE; + pub const DISJOINT_KHR: Self = Self::DISJOINT; + pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl ImageAspectFlags { + pub const PLANE_0_KHR: Self = Self::PLANE_0; + pub const PLANE_1_KHR: Self = Self::PLANE_1; + pub const PLANE_2_KHR: Self = Self::PLANE_2; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl ImageCreateFlags { + pub const DISJOINT_KHR: Self = Self::DISJOINT; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl ObjectType { + pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl SamplerYcbcrModelConversion { + pub const RGB_IDENTITY_KHR: Self = Self::RGB_IDENTITY; + pub const YCBCR_IDENTITY_KHR: Self = Self::YCBCR_IDENTITY; + pub const YCBCR_709_KHR: Self = Self::YCBCR_709; + pub const YCBCR_601_KHR: Self = Self::YCBCR_601; + pub const YCBCR_2020_KHR: Self = Self::YCBCR_2020; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl SamplerYcbcrRange { + pub const ITU_FULL_KHR: Self = Self::ITU_FULL; + pub const ITU_NARROW_KHR: Self = Self::ITU_NARROW; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self = + Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO; + pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION_INFO; + pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_PLANE_MEMORY_INFO; + pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self = + Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; + pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self = + Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; +} +impl KhrBindMemory2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_bind_memory2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkBindBufferMemory2 = unsafe extern "system" fn( + device: Device, + bind_info_count: u32, + p_bind_infos: *const BindBufferMemoryInfo, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkBindImageMemory2 = unsafe extern "system" fn( + device: Device, + bind_info_count: u32, + p_bind_infos: *const BindImageMemoryInfo, +) -> Result; +#[derive(Clone)] +pub struct KhrBindMemory2Fn { + pub bind_buffer_memory2_khr: PFN_vkBindBufferMemory2, + pub bind_image_memory2_khr: PFN_vkBindImageMemory2, +} +unsafe impl Send for KhrBindMemory2Fn {} +unsafe impl Sync for KhrBindMemory2Fn {} +impl KhrBindMemory2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + bind_buffer_memory2_khr: unsafe { + unsafe extern "system" fn bind_buffer_memory2_khr( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindBufferMemoryInfo, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_buffer_memory2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2KHR\0"); + let val = _f(cname); + if val.is_null() { + bind_buffer_memory2_khr + } else { + ::std::mem::transmute(val) + } + }, + bind_image_memory2_khr: unsafe { + unsafe extern "system" fn bind_image_memory2_khr( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindImageMemoryInfo, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_image_memory2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2KHR\0"); + let val = _f(cname); + if val.is_null() { + bind_image_memory2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_bind_memory2'"] +impl ImageCreateFlags { + pub const ALIAS_KHR: Self = Self::ALIAS; +} +#[doc = "Generated from 'VK_KHR_bind_memory2'"] +impl StructureType { + pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = Self::BIND_BUFFER_MEMORY_INFO; + pub const BIND_IMAGE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_MEMORY_INFO; +} +impl ExtImageDrmFormatModifierFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_drm_format_modifier\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn( + device: Device, + image: Image, + p_properties: *mut ImageDrmFormatModifierPropertiesEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtImageDrmFormatModifierFn { + pub get_image_drm_format_modifier_properties_ext: PFN_vkGetImageDrmFormatModifierPropertiesEXT, +} +unsafe impl Send for ExtImageDrmFormatModifierFn {} +unsafe impl Sync for ExtImageDrmFormatModifierFn {} +impl ExtImageDrmFormatModifierFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_image_drm_format_modifier_properties_ext: unsafe { + unsafe extern "system" fn get_image_drm_format_modifier_properties_ext( + _device: Device, + _image: Image, + _p_properties: *mut ImageDrmFormatModifierPropertiesEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_drm_format_modifier_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageDrmFormatModifierPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_drm_format_modifier_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl ImageAspectFlags { + pub const MEMORY_PLANE_0_EXT: Self = Self(0b1000_0000); + pub const MEMORY_PLANE_1_EXT: Self = Self(0b1_0000_0000); + pub const MEMORY_PLANE_2_EXT: Self = Self(0b10_0000_0000); + pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl ImageTiling { + pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1_000_158_000); +} +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl Result { + pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1_000_158_000); +} +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl StructureType { + pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1_000_158_000); + pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1_000_158_002); + pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: Self = Self(1_000_158_003); + pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: Self = Self(1_000_158_004); + pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1_000_158_005); + pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: Self = Self(1_000_158_006); +} +impl ExtExtension160Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_160\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension160Fn {} +unsafe impl Send for ExtExtension160Fn {} +unsafe impl Sync for ExtExtension160Fn {} +impl ExtExtension160Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtValidationCacheFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_cache\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateValidationCacheEXT = unsafe extern "system" fn( + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *mut ValidationCacheEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyValidationCacheEXT = unsafe extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkMergeValidationCachesEXT = unsafe extern "system" fn( + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: u32, + p_src_caches: *const ValidationCacheEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetValidationCacheDataEXT = unsafe extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *mut usize, + p_data: *mut c_void, +) -> Result; +#[derive(Clone)] +pub struct ExtValidationCacheFn { + pub create_validation_cache_ext: PFN_vkCreateValidationCacheEXT, + pub destroy_validation_cache_ext: PFN_vkDestroyValidationCacheEXT, + pub merge_validation_caches_ext: PFN_vkMergeValidationCachesEXT, + pub get_validation_cache_data_ext: PFN_vkGetValidationCacheDataEXT, +} +unsafe impl Send for ExtValidationCacheFn {} +unsafe impl Sync for ExtValidationCacheFn {} +impl ExtValidationCacheFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_validation_cache_ext: unsafe { + unsafe extern "system" fn create_validation_cache_ext( + _device: Device, + _p_create_info: *const ValidationCacheCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_validation_cache: *mut ValidationCacheEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_validation_cache_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateValidationCacheEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_validation_cache_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_validation_cache_ext: unsafe { + unsafe extern "system" fn destroy_validation_cache_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_validation_cache_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyValidationCacheEXT\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_validation_cache_ext + } else { + ::std::mem::transmute(val) + } + }, + merge_validation_caches_ext: unsafe { + unsafe extern "system" fn merge_validation_caches_ext( + _device: Device, + _dst_cache: ValidationCacheEXT, + _src_cache_count: u32, + _p_src_caches: *const ValidationCacheEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(merge_validation_caches_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkMergeValidationCachesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + merge_validation_caches_ext + } else { + ::std::mem::transmute(val) + } + }, + get_validation_cache_data_ext: unsafe { + unsafe extern "system" fn get_validation_cache_data_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_validation_cache_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetValidationCacheDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_validation_cache_data_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_validation_cache'"] +impl ObjectType { + pub const VALIDATION_CACHE_EXT: Self = Self(1_000_160_000); +} +#[doc = "Generated from 'VK_EXT_validation_cache'"] +impl StructureType { + pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_000); + pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_001); +} +impl ExtDescriptorIndexingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_indexing\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtDescriptorIndexingFn {} +unsafe impl Send for ExtDescriptorIndexingFn {} +unsafe impl Sync for ExtDescriptorIndexingFn {} +impl ExtDescriptorIndexingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl DescriptorBindingFlags { + pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND; + pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = Self::UPDATE_UNUSED_WHILE_PENDING; + pub const PARTIALLY_BOUND_EXT: Self = Self::PARTIALLY_BOUND; + pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = Self::VARIABLE_DESCRIPTOR_COUNT; +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl DescriptorPoolCreateFlags { + pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND; +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl DescriptorSetLayoutCreateFlags { + pub const UPDATE_AFTER_BIND_POOL_EXT: Self = Self::UPDATE_AFTER_BIND_POOL; +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl Result { + pub const ERROR_FRAGMENTATION_EXT: Self = Self::ERROR_FRAGMENTATION; +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl StructureType { + pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self = + Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self = + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self = + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; +} +impl ExtShaderViewportIndexLayerFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_viewport_index_layer\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderViewportIndexLayerFn {} +unsafe impl Send for ExtShaderViewportIndexLayerFn {} +unsafe impl Sync for ExtShaderViewportIndexLayerFn {} +impl ExtShaderViewportIndexLayerFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrPortabilitySubsetFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_subset\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrPortabilitySubsetFn {} +unsafe impl Send for KhrPortabilitySubsetFn {} +unsafe impl Sync for KhrPortabilitySubsetFn {} +impl KhrPortabilitySubsetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_portability_subset'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: Self = Self(1_000_163_000); + pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: Self = Self(1_000_163_001); +} +impl NvShadingRateImageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shading_rate_image\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindShadingRateImageNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image_view: ImageView, + image_layout: ImageLayout, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportShadingRatePaletteNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_shading_rate_palettes: *const ShadingRatePaletteNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoarseSampleOrderNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + sample_order_type: CoarseSampleOrderTypeNV, + custom_sample_order_count: u32, + p_custom_sample_orders: *const CoarseSampleOrderCustomNV, +); +#[derive(Clone)] +pub struct NvShadingRateImageFn { + pub cmd_bind_shading_rate_image_nv: PFN_vkCmdBindShadingRateImageNV, + pub cmd_set_viewport_shading_rate_palette_nv: PFN_vkCmdSetViewportShadingRatePaletteNV, + pub cmd_set_coarse_sample_order_nv: PFN_vkCmdSetCoarseSampleOrderNV, +} +unsafe impl Send for NvShadingRateImageFn {} +unsafe impl Sync for NvShadingRateImageFn {} +impl NvShadingRateImageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_bind_shading_rate_image_nv: unsafe { + unsafe extern "system" fn cmd_bind_shading_rate_image_nv( + _command_buffer: CommandBuffer, + _image_view: ImageView, + _image_layout: ImageLayout, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_shading_rate_image_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindShadingRateImageNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_shading_rate_image_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_shading_rate_palette_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_shading_rate_palette_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_shading_rate_palettes: *const ShadingRatePaletteNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_shading_rate_palette_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportShadingRatePaletteNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_shading_rate_palette_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coarse_sample_order_nv: unsafe { + unsafe extern "system" fn cmd_set_coarse_sample_order_nv( + _command_buffer: CommandBuffer, + _sample_order_type: CoarseSampleOrderTypeNV, + _custom_sample_order_count: u32, + _p_custom_sample_orders: *const CoarseSampleOrderCustomNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coarse_sample_order_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoarseSampleOrderNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coarse_sample_order_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl AccessFlags { + pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR; +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl DynamicState { + pub const VIEWPORT_SHADING_RATE_PALETTE_NV: Self = Self(1_000_164_004); + pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1_000_164_006); +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl ImageLayout { + pub const SHADING_RATE_OPTIMAL_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR; +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl ImageUsageFlags { + pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl PipelineStageFlags { + pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1_000_164_000); + pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1_000_164_001); + pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1_000_164_002); + pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: Self = + Self(1_000_164_005); +} +impl NvRayTracingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateAccelerationStructureNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const AccelerationStructureCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_acceleration_structure: *mut AccelerationStructureNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyAccelerationStructureNV = unsafe extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureNV, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = unsafe extern "system" fn( + device: Device, + p_info: *const AccelerationStructureMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2KHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBindAccelerationStructureMemoryNV = unsafe extern "system" fn( + device: Device, + bind_info_count: u32, + p_bind_infos: *const BindAccelerationStructureMemoryInfoNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildAccelerationStructureNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const AccelerationStructureInfoNV, + instance_data: Buffer, + instance_offset: DeviceSize, + update: Bool32, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, + scratch: Buffer, + scratch_offset: DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyAccelerationStructureNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, + mode: CopyAccelerationStructureModeKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + raygen_shader_binding_table_buffer: Buffer, + raygen_shader_binding_offset: DeviceSize, + miss_shader_binding_table_buffer: Buffer, + miss_shader_binding_offset: DeviceSize, + miss_shader_binding_stride: DeviceSize, + hit_shader_binding_table_buffer: Buffer, + hit_shader_binding_offset: DeviceSize, + hit_shader_binding_stride: DeviceSize, + callable_shader_binding_table_buffer: Buffer, + callable_shader_binding_offset: DeviceSize, + callable_shader_binding_stride: DeviceSize, + width: u32, + height: u32, + depth: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRayTracingPipelinesNV = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureHandleNV = unsafe extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureNV, + data_size: usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + acceleration_structure_count: u32, + p_acceleration_structures: *const AccelerationStructureNV, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCompileDeferredNV = + unsafe extern "system" fn(device: Device, pipeline: Pipeline, shader: u32) -> Result; +#[derive(Clone)] +pub struct NvRayTracingFn { + pub create_acceleration_structure_nv: PFN_vkCreateAccelerationStructureNV, + pub destroy_acceleration_structure_nv: PFN_vkDestroyAccelerationStructureNV, + pub get_acceleration_structure_memory_requirements_nv: + PFN_vkGetAccelerationStructureMemoryRequirementsNV, + pub bind_acceleration_structure_memory_nv: PFN_vkBindAccelerationStructureMemoryNV, + pub cmd_build_acceleration_structure_nv: PFN_vkCmdBuildAccelerationStructureNV, + pub cmd_copy_acceleration_structure_nv: PFN_vkCmdCopyAccelerationStructureNV, + pub cmd_trace_rays_nv: PFN_vkCmdTraceRaysNV, + pub create_ray_tracing_pipelines_nv: PFN_vkCreateRayTracingPipelinesNV, + pub get_ray_tracing_shader_group_handles_nv: + crate::vk::PFN_vkGetRayTracingShaderGroupHandlesKHR, + pub get_acceleration_structure_handle_nv: PFN_vkGetAccelerationStructureHandleNV, + pub cmd_write_acceleration_structures_properties_nv: + PFN_vkCmdWriteAccelerationStructuresPropertiesNV, + pub compile_deferred_nv: PFN_vkCompileDeferredNV, +} +unsafe impl Send for NvRayTracingFn {} +unsafe impl Sync for NvRayTracingFn {} +impl NvRayTracingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_acceleration_structure_nv: unsafe { + unsafe extern "system" fn create_acceleration_structure_nv( + _device: Device, + _p_create_info: *const AccelerationStructureCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_acceleration_structure: *mut AccelerationStructureNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_acceleration_structure_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateAccelerationStructureNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_acceleration_structure_nv: unsafe { + unsafe extern "system" fn destroy_acceleration_structure_nv( + _device: Device, + _acceleration_structure: AccelerationStructureNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_acceleration_structure_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyAccelerationStructureNV\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_memory_requirements_nv: unsafe { + unsafe extern "system" fn get_acceleration_structure_memory_requirements_nv( + _device: Device, + _p_info: *const AccelerationStructureMemoryRequirementsInfoNV, + _p_memory_requirements: *mut MemoryRequirements2KHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_memory_requirements_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureMemoryRequirementsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_memory_requirements_nv + } else { + ::std::mem::transmute(val) + } + }, + bind_acceleration_structure_memory_nv: unsafe { + unsafe extern "system" fn bind_acceleration_structure_memory_nv( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindAccelerationStructureMemoryInfoNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_acceleration_structure_memory_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBindAccelerationStructureMemoryNV\0", + ); + let val = _f(cname); + if val.is_null() { + bind_acceleration_structure_memory_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_acceleration_structure_nv: unsafe { + unsafe extern "system" fn cmd_build_acceleration_structure_nv( + _command_buffer: CommandBuffer, + _p_info: *const AccelerationStructureInfoNV, + _instance_data: Buffer, + _instance_offset: DeviceSize, + _update: Bool32, + _dst: AccelerationStructureNV, + _src: AccelerationStructureNV, + _scratch: Buffer, + _scratch_offset: DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_acceleration_structure_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBuildAccelerationStructureNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_build_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_acceleration_structure_nv: unsafe { + unsafe extern "system" fn cmd_copy_acceleration_structure_nv( + _command_buffer: CommandBuffer, + _dst: AccelerationStructureNV, + _src: AccelerationStructureNV, + _mode: CopyAccelerationStructureModeKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_acceleration_structure_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyAccelerationStructureNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_trace_rays_nv: unsafe { + unsafe extern "system" fn cmd_trace_rays_nv( + _command_buffer: CommandBuffer, + _raygen_shader_binding_table_buffer: Buffer, + _raygen_shader_binding_offset: DeviceSize, + _miss_shader_binding_table_buffer: Buffer, + _miss_shader_binding_offset: DeviceSize, + _miss_shader_binding_stride: DeviceSize, + _hit_shader_binding_table_buffer: Buffer, + _hit_shader_binding_offset: DeviceSize, + _hit_shader_binding_stride: DeviceSize, + _callable_shader_binding_table_buffer: Buffer, + _callable_shader_binding_offset: DeviceSize, + _callable_shader_binding_stride: DeviceSize, + _width: u32, + _height: u32, + _depth: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_nv))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_nv + } else { + ::std::mem::transmute(val) + } + }, + create_ray_tracing_pipelines_nv: unsafe { + unsafe extern "system" fn create_ray_tracing_pipelines_nv( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const RayTracingPipelineCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ray_tracing_pipelines_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateRayTracingPipelinesNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_ray_tracing_pipelines_nv + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_handles_nv: unsafe { + unsafe extern "system" fn get_ray_tracing_shader_group_handles_nv( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_handles_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRayTracingShaderGroupHandlesNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_ray_tracing_shader_group_handles_nv + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_handle_nv: unsafe { + unsafe extern "system" fn get_acceleration_structure_handle_nv( + _device: Device, + _acceleration_structure: AccelerationStructureNV, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_handle_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureHandleNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_handle_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_acceleration_structures_properties_nv: unsafe { + unsafe extern "system" fn cmd_write_acceleration_structures_properties_nv( + _command_buffer: CommandBuffer, + _acceleration_structure_count: u32, + _p_acceleration_structures: *const AccelerationStructureNV, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_acceleration_structures_properties_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteAccelerationStructuresPropertiesNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_acceleration_structures_properties_nv + } else { + ::std::mem::transmute(val) + } + }, + compile_deferred_nv: unsafe { + unsafe extern "system" fn compile_deferred_nv( + _device: Device, + _pipeline: Pipeline, + _shader: u32, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(compile_deferred_nv))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCompileDeferredNV\0"); + let val = _f(cname); + if val.is_null() { + compile_deferred_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl AccelerationStructureTypeKHR { + pub const TOP_LEVEL_NV: Self = Self::TOP_LEVEL; + pub const BOTTOM_LEVEL_NV: Self = Self::BOTTOM_LEVEL; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl AccessFlags { + pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR; + pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl BufferUsageFlags { + pub const RAY_TRACING_NV: Self = Self::SHADER_BINDING_TABLE_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_UPDATE_NV: Self = Self::ALLOW_UPDATE; + pub const ALLOW_COMPACTION_NV: Self = Self::ALLOW_COMPACTION; + pub const PREFER_FAST_TRACE_NV: Self = Self::PREFER_FAST_TRACE; + pub const PREFER_FAST_BUILD_NV: Self = Self::PREFER_FAST_BUILD; + pub const LOW_MEMORY_NV: Self = Self::LOW_MEMORY; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl CopyAccelerationStructureModeKHR { + pub const CLONE_NV: Self = Self::CLONE; + pub const COMPACT_NV: Self = Self::COMPACT; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl DebugReportObjectTypeEXT { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl DescriptorType { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl GeometryFlagsKHR { + pub const OPAQUE_NV: Self = Self::OPAQUE; + pub const NO_DUPLICATE_ANY_HIT_INVOCATION_NV: Self = Self::NO_DUPLICATE_ANY_HIT_INVOCATION; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl GeometryInstanceFlagsKHR { + pub const TRIANGLE_CULL_DISABLE_NV: Self = Self::TRIANGLE_FACING_CULL_DISABLE; + pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_NV: Self = Self::TRIANGLE_FRONT_COUNTERCLOCKWISE; + pub const FORCE_OPAQUE_NV: Self = Self::FORCE_OPAQUE; + pub const FORCE_NO_OPAQUE_NV: Self = Self::FORCE_NO_OPAQUE; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl GeometryTypeKHR { + pub const TRIANGLES_NV: Self = Self::TRIANGLES; + pub const AABBS_NV: Self = Self::AABBS; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl IndexType { + pub const NONE_NV: Self = Self::NONE_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl ObjectType { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl PipelineBindPoint { + pub const RAY_TRACING_NV: Self = Self::RAY_TRACING_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl PipelineCreateFlags { + pub const DEFER_COMPILE_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl PipelineStageFlags { + pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR; + pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl QueryType { + pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl RayTracingShaderGroupTypeKHR { + pub const GENERAL_NV: Self = Self::GENERAL; + pub const TRIANGLES_HIT_GROUP_NV: Self = Self::TRIANGLES_HIT_GROUP; + pub const PROCEDURAL_HIT_GROUP_NV: Self = Self::PROCEDURAL_HIT_GROUP; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl ShaderStageFlags { + pub const RAYGEN_NV: Self = Self::RAYGEN_KHR; + pub const ANY_HIT_NV: Self = Self::ANY_HIT_KHR; + pub const CLOSEST_HIT_NV: Self = Self::CLOSEST_HIT_KHR; + pub const MISS_NV: Self = Self::MISS_KHR; + pub const INTERSECTION_NV: Self = Self::INTERSECTION_KHR; + pub const CALLABLE_NV: Self = Self::CALLABLE_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl StructureType { + pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1_000_165_000); + pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1_000_165_001); + pub const GEOMETRY_NV: Self = Self(1_000_165_003); + pub const GEOMETRY_TRIANGLES_NV: Self = Self(1_000_165_004); + pub const GEOMETRY_AABB_NV: Self = Self(1_000_165_005); + pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = Self(1_000_165_006); + pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_007); + pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_165_008); + pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1_000_165_009); + pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_165_011); + pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1_000_165_012); +} +impl NvRepresentativeFragmentTestFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_representative_fragment_test\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvRepresentativeFragmentTestFn {} +unsafe impl Send for NvRepresentativeFragmentTestFn {} +unsafe impl Sync for NvRepresentativeFragmentTestFn {} +impl NvRepresentativeFragmentTestFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_representative_fragment_test'"] +impl StructureType { + pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self(1_000_166_000); + pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: Self = + Self(1_000_166_001); +} +impl NvExtension168Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_168\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension168Fn {} +unsafe impl Send for NvExtension168Fn {} +unsafe impl Sync for NvExtension168Fn {} +impl NvExtension168Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrMaintenance3Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance3\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutSupport = unsafe extern "system" fn( + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_support: *mut DescriptorSetLayoutSupport, +); +#[derive(Clone)] +pub struct KhrMaintenance3Fn { + pub get_descriptor_set_layout_support_khr: PFN_vkGetDescriptorSetLayoutSupport, +} +unsafe impl Send for KhrMaintenance3Fn {} +unsafe impl Sync for KhrMaintenance3Fn {} +impl KhrMaintenance3Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_descriptor_set_layout_support_khr: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_support_khr( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_support: *mut DescriptorSetLayoutSupport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_maintenance3'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; + pub const DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: Self = Self::DESCRIPTOR_SET_LAYOUT_SUPPORT; +} +impl KhrDrawIndirectCountFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_draw_indirect_count\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrDrawIndirectCountFn { + pub cmd_draw_indirect_count_khr: crate::vk::PFN_vkCmdDrawIndirectCount, + pub cmd_draw_indexed_indirect_count_khr: crate::vk::PFN_vkCmdDrawIndexedIndirectCount, +} +unsafe impl Send for KhrDrawIndirectCountFn {} +unsafe impl Sync for KhrDrawIndirectCountFn {} +impl KhrDrawIndirectCountFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_indirect_count_khr: unsafe { + unsafe extern "system" fn cmd_draw_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect_count_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect_count_khr: unsafe { + unsafe extern "system" fn cmd_draw_indexed_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawIndexedIndirectCountKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed_indirect_count_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtFilterCubicFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_filter_cubic\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct ExtFilterCubicFn {} +unsafe impl Send for ExtFilterCubicFn {} +unsafe impl Sync for ExtFilterCubicFn {} +impl ExtFilterCubicFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_filter_cubic'"] +impl Filter { + pub const CUBIC_EXT: Self = Self(1_000_015_000); +} +#[doc = "Generated from 'VK_EXT_filter_cubic'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self(0b10_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_filter_cubic'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: Self = Self(1_000_170_000); + pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1_000_170_001); +} +impl QcomRenderPassShaderResolveFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_shader_resolve\0") + } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[derive(Clone)] +pub struct QcomRenderPassShaderResolveFn {} +unsafe impl Send for QcomRenderPassShaderResolveFn {} +unsafe impl Sync for QcomRenderPassShaderResolveFn {} +impl QcomRenderPassShaderResolveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_render_pass_shader_resolve'"] +impl SubpassDescriptionFlags { + pub const FRAGMENT_REGION_QCOM: Self = Self(0b100); + pub const SHADER_RESOLVE_QCOM: Self = Self(0b1000); +} +impl QcomExtension173Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_173\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension173Fn {} +unsafe impl Send for QcomExtension173Fn {} +unsafe impl Sync for QcomExtension173Fn {} +impl QcomExtension173Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_173'"] +impl BufferUsageFlags { + pub const RESERVED_18_QCOM: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_extension_173'"] +impl ImageUsageFlags { + pub const RESERVED_16_QCOM: Self = Self(0b1_0000_0000_0000_0000); + pub const RESERVED_17_QCOM: Self = Self(0b10_0000_0000_0000_0000); +} +impl QcomExtension174Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_174\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension174Fn {} +unsafe impl Send for QcomExtension174Fn {} +unsafe impl Sync for QcomExtension174Fn {} +impl QcomExtension174Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtGlobalPriorityFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtGlobalPriorityFn {} +unsafe impl Send for ExtGlobalPriorityFn {} +unsafe impl Sync for ExtGlobalPriorityFn {} +impl ExtGlobalPriorityFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_global_priority'"] +impl Result { + pub const ERROR_NOT_PERMITTED_EXT: Self = Self::ERROR_NOT_PERMITTED_KHR; +} +#[doc = "Generated from 'VK_EXT_global_priority'"] +impl StructureType { + pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = + Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR; +} +impl KhrShaderSubgroupExtendedTypesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_shader_subgroup_extended_types\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderSubgroupExtendedTypesFn {} +unsafe impl Send for KhrShaderSubgroupExtendedTypesFn {} +unsafe impl Sync for KhrShaderSubgroupExtendedTypesFn {} +impl KhrShaderSubgroupExtendedTypesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_subgroup_extended_types'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; +} +impl ExtExtension177Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_177\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension177Fn {} +unsafe impl Send for ExtExtension177Fn {} +unsafe impl Sync for ExtExtension177Fn {} +impl ExtExtension177Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl Khr8bitStorageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_8bit_storage\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct Khr8bitStorageFn {} +unsafe impl Send for Khr8bitStorageFn {} +unsafe impl Sync for Khr8bitStorageFn {} +impl Khr8bitStorageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_8bit_storage'"] +impl StructureType { + pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; +} +impl ExtExternalMemoryHostFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_host\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryHostPointerPropertiesEXT = unsafe extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + p_host_pointer: *const c_void, + p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtExternalMemoryHostFn { + pub get_memory_host_pointer_properties_ext: PFN_vkGetMemoryHostPointerPropertiesEXT, +} +unsafe impl Send for ExtExternalMemoryHostFn {} +unsafe impl Sync for ExtExternalMemoryHostFn {} +impl ExtExternalMemoryHostFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_host_pointer_properties_ext: unsafe { + unsafe extern "system" fn get_memory_host_pointer_properties_ext( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _p_host_pointer: *const c_void, + _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_host_pointer_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryHostPointerPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_host_pointer_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_external_memory_host'"] +impl ExternalMemoryHandleTypeFlags { + pub const HOST_ALLOCATION_EXT: Self = Self(0b1000_0000); + pub const HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_EXT_external_memory_host'"] +impl StructureType { + pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1_000_178_000); + pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = Self(1_000_178_001); + pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = Self(1_000_178_002); +} +impl AmdBufferMarkerFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_buffer_marker\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteBufferMarkerAMD = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, +); +#[derive(Clone)] +pub struct AmdBufferMarkerFn { + pub cmd_write_buffer_marker_amd: PFN_vkCmdWriteBufferMarkerAMD, +} +unsafe impl Send for AmdBufferMarkerFn {} +unsafe impl Sync for AmdBufferMarkerFn {} +impl AmdBufferMarkerFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_write_buffer_marker_amd: unsafe { + unsafe extern "system" fn cmd_write_buffer_marker_amd( + _command_buffer: CommandBuffer, + _pipeline_stage: PipelineStageFlags, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _marker: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_buffer_marker_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteBufferMarkerAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_write_buffer_marker_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl KhrShaderAtomicInt64Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_atomic_int64\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderAtomicInt64Fn {} +unsafe impl Send for KhrShaderAtomicInt64Fn {} +unsafe impl Sync for KhrShaderAtomicInt64Fn {} +impl KhrShaderAtomicInt64Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_atomic_int64'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; +} +impl KhrShaderClockFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_clock\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderClockFn {} +unsafe impl Send for KhrShaderClockFn {} +unsafe impl Sync for KhrShaderClockFn {} +impl KhrShaderClockFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_clock'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1_000_181_000); +} +impl AmdExtension183Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_183\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension183Fn {} +unsafe impl Send for AmdExtension183Fn {} +unsafe impl Sync for AmdExtension183Fn {} +impl AmdExtension183Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdPipelineCompilerControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_pipeline_compiler_control\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdPipelineCompilerControlFn {} +unsafe impl Send for AmdPipelineCompilerControlFn {} +unsafe impl Sync for AmdPipelineCompilerControlFn {} +impl AmdPipelineCompilerControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_pipeline_compiler_control'"] +impl StructureType { + pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1_000_183_000); +} +impl ExtCalibratedTimestampsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_calibrated_timestamps\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_time_domain_count: *mut u32, + p_time_domains: *mut TimeDomainEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetCalibratedTimestampsEXT = unsafe extern "system" fn( + device: Device, + timestamp_count: u32, + p_timestamp_infos: *const CalibratedTimestampInfoEXT, + p_timestamps: *mut u64, + p_max_deviation: *mut u64, +) -> Result; +#[derive(Clone)] +pub struct ExtCalibratedTimestampsFn { + pub get_physical_device_calibrateable_time_domains_ext: + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + pub get_calibrated_timestamps_ext: PFN_vkGetCalibratedTimestampsEXT, +} +unsafe impl Send for ExtCalibratedTimestampsFn {} +unsafe impl Sync for ExtCalibratedTimestampsFn {} +impl ExtCalibratedTimestampsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_calibrateable_time_domains_ext: unsafe { + unsafe extern "system" fn get_physical_device_calibrateable_time_domains_ext( + _physical_device: PhysicalDevice, + _p_time_domain_count: *mut u32, + _p_time_domains: *mut TimeDomainEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_calibrateable_time_domains_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_calibrateable_time_domains_ext + } else { + ::std::mem::transmute(val) + } + }, + get_calibrated_timestamps_ext: unsafe { + unsafe extern "system" fn get_calibrated_timestamps_ext( + _device: Device, + _timestamp_count: u32, + _p_timestamp_infos: *const CalibratedTimestampInfoEXT, + _p_timestamps: *mut u64, + _p_max_deviation: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_calibrated_timestamps_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetCalibratedTimestampsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_calibrated_timestamps_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_calibrated_timestamps'"] +impl StructureType { + pub const CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1_000_184_000); +} +impl AmdShaderCorePropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct AmdShaderCorePropertiesFn {} +unsafe impl Send for AmdShaderCorePropertiesFn {} +unsafe impl Sync for AmdShaderCorePropertiesFn {} +impl AmdShaderCorePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_shader_core_properties'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1_000_185_000); +} +impl AmdExtension187Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_187\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension187Fn {} +unsafe impl Send for AmdExtension187Fn {} +unsafe impl Sync for AmdExtension187Fn {} +impl AmdExtension187Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrVideoDecodeH265Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h265\0") } + } + pub const SPEC_VERSION: u32 = 7u32; +} +#[derive(Clone)] +pub struct KhrVideoDecodeH265Fn {} +unsafe impl Send for KhrVideoDecodeH265Fn {} +unsafe impl Sync for KhrVideoDecodeH265Fn {} +impl KhrVideoDecodeH265Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_video_decode_h265'"] +impl StructureType { + pub const VIDEO_DECODE_H265_CAPABILITIES_KHR: Self = Self(1_000_187_000); + pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_187_001); + pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_187_002); + pub const VIDEO_DECODE_H265_PROFILE_INFO_KHR: Self = Self(1_000_187_003); + pub const VIDEO_DECODE_H265_PICTURE_INFO_KHR: Self = Self(1_000_187_004); + pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: Self = Self(1_000_187_005); +} +#[doc = "Generated from 'VK_KHR_video_decode_h265'"] +impl VideoCodecOperationFlagsKHR { + pub const DECODE_H265: Self = Self(0b10); +} +impl KhrGlobalPriorityFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_global_priority\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrGlobalPriorityFn {} +unsafe impl Send for KhrGlobalPriorityFn {} +unsafe impl Sync for KhrGlobalPriorityFn {} +impl KhrGlobalPriorityFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_global_priority'"] +impl Result { + pub const ERROR_NOT_PERMITTED_KHR: Self = Self(-1_000_174_001); +} +#[doc = "Generated from 'VK_KHR_global_priority'"] +impl StructureType { + pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: Self = Self(1_000_174_000); + pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: Self = Self(1_000_388_000); + pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: Self = Self(1_000_388_001); +} +impl AmdMemoryOverallocationBehaviorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_AMD_memory_overallocation_behavior\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdMemoryOverallocationBehaviorFn {} +unsafe impl Send for AmdMemoryOverallocationBehaviorFn {} +unsafe impl Sync for AmdMemoryOverallocationBehaviorFn {} +impl AmdMemoryOverallocationBehaviorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_memory_overallocation_behavior'"] +impl StructureType { + pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1_000_189_000); +} +impl ExtVertexAttributeDivisorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_attribute_divisor\0") + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct ExtVertexAttributeDivisorFn {} +unsafe impl Send for ExtVertexAttributeDivisorFn {} +unsafe impl Sync for ExtVertexAttributeDivisorFn {} +impl ExtVertexAttributeDivisorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_vertex_attribute_divisor'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = Self(1_000_190_000); + pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = Self(1_000_190_001); + pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: Self = Self(1_000_190_002); +} +impl GgpFrameTokenFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_frame_token\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct GgpFrameTokenFn {} +unsafe impl Send for GgpFrameTokenFn {} +unsafe impl Sync for GgpFrameTokenFn {} +impl GgpFrameTokenFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_GGP_frame_token'"] +impl StructureType { + pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1_000_191_000); +} +impl ExtPipelineCreationFeedbackFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_creation_feedback\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPipelineCreationFeedbackFn {} +unsafe impl Send for ExtPipelineCreationFeedbackFn {} +unsafe impl Sync for ExtPipelineCreationFeedbackFn {} +impl ExtPipelineCreationFeedbackFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_feedback'"] +impl StructureType { + pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = + Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO; +} +impl GoogleExtension194Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_194\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension194Fn {} +unsafe impl Send for GoogleExtension194Fn {} +unsafe impl Sync for GoogleExtension194Fn {} +impl GoogleExtension194Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension195Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_195\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension195Fn {} +unsafe impl Send for GoogleExtension195Fn {} +unsafe impl Sync for GoogleExtension195Fn {} +impl GoogleExtension195Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension196Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_196\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension196Fn {} +unsafe impl Send for GoogleExtension196Fn {} +unsafe impl Sync for GoogleExtension196Fn {} +impl GoogleExtension196Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_GOOGLE_extension_196'"] +impl PipelineCacheCreateFlags { + pub const RESERVED_1_EXT: Self = Self(0b10); +} +impl KhrDriverPropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_driver_properties\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrDriverPropertiesFn {} +unsafe impl Send for KhrDriverPropertiesFn {} +unsafe impl Sync for KhrDriverPropertiesFn {} +impl KhrDriverPropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_driver_properties'"] +impl DriverId { + pub const AMD_PROPRIETARY_KHR: Self = Self::AMD_PROPRIETARY; + pub const AMD_OPEN_SOURCE_KHR: Self = Self::AMD_OPEN_SOURCE; + pub const MESA_RADV_KHR: Self = Self::MESA_RADV; + pub const NVIDIA_PROPRIETARY_KHR: Self = Self::NVIDIA_PROPRIETARY; + pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = Self::INTEL_PROPRIETARY_WINDOWS; + pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = Self::INTEL_OPEN_SOURCE_MESA; + pub const IMAGINATION_PROPRIETARY_KHR: Self = Self::IMAGINATION_PROPRIETARY; + pub const QUALCOMM_PROPRIETARY_KHR: Self = Self::QUALCOMM_PROPRIETARY; + pub const ARM_PROPRIETARY_KHR: Self = Self::ARM_PROPRIETARY; + pub const GOOGLE_SWIFTSHADER_KHR: Self = Self::GOOGLE_SWIFTSHADER; + pub const GGP_PROPRIETARY_KHR: Self = Self::GGP_PROPRIETARY; + pub const BROADCOM_PROPRIETARY_KHR: Self = Self::BROADCOM_PROPRIETARY; +} +#[doc = "Generated from 'VK_KHR_driver_properties'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES; +} +impl KhrShaderFloatControlsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float_controls\0") + } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[derive(Clone)] +pub struct KhrShaderFloatControlsFn {} +unsafe impl Send for KhrShaderFloatControlsFn {} +unsafe impl Sync for KhrShaderFloatControlsFn {} +impl KhrShaderFloatControlsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_float_controls'"] +impl ShaderFloatControlsIndependence { + pub const TYPE_32_ONLY_KHR: Self = Self::TYPE_32_ONLY; + pub const ALL_KHR: Self = Self::ALL; + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_shader_float_controls'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; +} +impl NvShaderSubgroupPartitionedFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_subgroup_partitioned\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvShaderSubgroupPartitionedFn {} +unsafe impl Send for NvShaderSubgroupPartitionedFn {} +unsafe impl Sync for NvShaderSubgroupPartitionedFn {} +impl NvShaderSubgroupPartitionedFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_shader_subgroup_partitioned'"] +impl SubgroupFeatureFlags { + pub const PARTITIONED_NV: Self = Self(0b1_0000_0000); +} +impl KhrDepthStencilResolveFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_depth_stencil_resolve\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrDepthStencilResolveFn {} +unsafe impl Send for KhrDepthStencilResolveFn {} +unsafe impl Sync for KhrDepthStencilResolveFn {} +impl KhrDepthStencilResolveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"] +impl ResolveModeFlags { + pub const NONE_KHR: Self = Self::NONE; + pub const SAMPLE_ZERO_KHR: Self = Self::SAMPLE_ZERO; + pub const AVERAGE_KHR: Self = Self::AVERAGE; + pub const MIN_KHR: Self = Self::MIN; + pub const MAX_KHR: Self = Self::MAX; +} +#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; + pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self = + Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; +} +impl KhrSwapchainMutableFormatFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain_mutable_format\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrSwapchainMutableFormatFn {} +unsafe impl Send for KhrSwapchainMutableFormatFn {} +unsafe impl Sync for KhrSwapchainMutableFormatFn {} +impl KhrSwapchainMutableFormatFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_swapchain_mutable_format'"] +impl SwapchainCreateFlagsKHR { + pub const MUTABLE_FORMAT: Self = Self(0b100); +} +impl NvComputeShaderDerivativesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_compute_shader_derivatives\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvComputeShaderDerivativesFn {} +unsafe impl Send for NvComputeShaderDerivativesFn {} +unsafe impl Sync for NvComputeShaderDerivativesFn {} +impl NvComputeShaderDerivativesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_compute_shader_derivatives'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: Self = Self(1_000_201_000); +} +impl NvMeshShaderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_mesh_shader\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, task_count: u32, first_task: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +); +#[derive(Clone)] +pub struct NvMeshShaderFn { + pub cmd_draw_mesh_tasks_nv: PFN_vkCmdDrawMeshTasksNV, + pub cmd_draw_mesh_tasks_indirect_nv: PFN_vkCmdDrawMeshTasksIndirectNV, + pub cmd_draw_mesh_tasks_indirect_count_nv: PFN_vkCmdDrawMeshTasksIndirectCountNV, +} +unsafe impl Send for NvMeshShaderFn {} +unsafe impl Sync for NvMeshShaderFn {} +impl NvMeshShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_mesh_tasks_nv: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_nv( + _command_buffer: CommandBuffer, + _task_count: u32, + _first_task: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_nv: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_nv( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawMeshTasksIndirectNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_count_nv: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_nv( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_count_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawMeshTasksIndirectCountNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_count_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_mesh_shader'"] +impl PipelineStageFlags { + pub const TASK_SHADER_NV: Self = Self::TASK_SHADER_EXT; + pub const MESH_SHADER_NV: Self = Self::MESH_SHADER_EXT; +} +#[doc = "Generated from 'VK_NV_mesh_shader'"] +impl ShaderStageFlags { + pub const TASK_NV: Self = Self::TASK_EXT; + pub const MESH_NV: Self = Self::MESH_EXT; +} +#[doc = "Generated from 'VK_NV_mesh_shader'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1_000_202_000); + pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1_000_202_001); +} +impl NvFragmentShaderBarycentricFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shader_barycentric\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvFragmentShaderBarycentricFn {} +unsafe impl Send for NvFragmentShaderBarycentricFn {} +unsafe impl Sync for NvFragmentShaderBarycentricFn {} +impl NvFragmentShaderBarycentricFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_fragment_shader_barycentric'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; +} +impl NvShaderImageFootprintFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_image_footprint\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvShaderImageFootprintFn {} +unsafe impl Send for NvShaderImageFootprintFn {} +unsafe impl Sync for NvShaderImageFootprintFn {} +impl NvShaderImageFootprintFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_shader_image_footprint'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self(1_000_204_000); +} +impl NvScissorExclusiveFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_scissor_exclusive\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_exclusive_scissor: u32, + exclusive_scissor_count: u32, + p_exclusive_scissors: *const Rect2D, +); +#[derive(Clone)] +pub struct NvScissorExclusiveFn { + pub cmd_set_exclusive_scissor_nv: PFN_vkCmdSetExclusiveScissorNV, +} +unsafe impl Send for NvScissorExclusiveFn {} +unsafe impl Sync for NvScissorExclusiveFn {} +impl NvScissorExclusiveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_exclusive_scissor_nv: unsafe { + unsafe extern "system" fn cmd_set_exclusive_scissor_nv( + _command_buffer: CommandBuffer, + _first_exclusive_scissor: u32, + _exclusive_scissor_count: u32, + _p_exclusive_scissors: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_exclusive_scissor_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetExclusiveScissorNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_exclusive_scissor_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_scissor_exclusive'"] +impl DynamicState { + pub const EXCLUSIVE_SCISSOR_NV: Self = Self(1_000_205_001); +} +#[doc = "Generated from 'VK_NV_scissor_exclusive'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1_000_205_000); + pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: Self = Self(1_000_205_002); +} +impl NvDeviceDiagnosticCheckpointsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_device_diagnostic_checkpoints\0", + ) + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCheckpointNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, p_checkpoint_marker: *const c_void); +#[allow(non_camel_case_types)] +pub type PFN_vkGetQueueCheckpointDataNV = unsafe extern "system" fn( + queue: Queue, + p_checkpoint_data_count: *mut u32, + p_checkpoint_data: *mut CheckpointDataNV, +); +#[derive(Clone)] +pub struct NvDeviceDiagnosticCheckpointsFn { + pub cmd_set_checkpoint_nv: PFN_vkCmdSetCheckpointNV, + pub get_queue_checkpoint_data_nv: PFN_vkGetQueueCheckpointDataNV, +} +unsafe impl Send for NvDeviceDiagnosticCheckpointsFn {} +unsafe impl Sync for NvDeviceDiagnosticCheckpointsFn {} +impl NvDeviceDiagnosticCheckpointsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_checkpoint_nv: unsafe { + unsafe extern "system" fn cmd_set_checkpoint_nv( + _command_buffer: CommandBuffer, + _p_checkpoint_marker: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_checkpoint_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCheckpointNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_checkpoint_nv + } else { + ::std::mem::transmute(val) + } + }, + get_queue_checkpoint_data_nv: unsafe { + unsafe extern "system" fn get_queue_checkpoint_data_nv( + _queue: Queue, + _p_checkpoint_data_count: *mut u32, + _p_checkpoint_data: *mut CheckpointDataNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_queue_checkpoint_data_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetQueueCheckpointDataNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_queue_checkpoint_data_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_device_diagnostic_checkpoints'"] +impl StructureType { + pub const CHECKPOINT_DATA_NV: Self = Self(1_000_206_000); + pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: Self = Self(1_000_206_001); +} +impl KhrTimelineSemaphoreFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_timeline_semaphore\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreCounterValue = + unsafe extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWaitSemaphores = unsafe extern "system" fn( + device: Device, + p_wait_info: *const SemaphoreWaitInfo, + timeout: u64, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSignalSemaphore = + unsafe extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result; +#[derive(Clone)] +pub struct KhrTimelineSemaphoreFn { + pub get_semaphore_counter_value_khr: PFN_vkGetSemaphoreCounterValue, + pub wait_semaphores_khr: PFN_vkWaitSemaphores, + pub signal_semaphore_khr: PFN_vkSignalSemaphore, +} +unsafe impl Send for KhrTimelineSemaphoreFn {} +unsafe impl Sync for KhrTimelineSemaphoreFn {} +impl KhrTimelineSemaphoreFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_semaphore_counter_value_khr: unsafe { + unsafe extern "system" fn get_semaphore_counter_value_khr( + _device: Device, + _semaphore: Semaphore, + _p_value: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_counter_value_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSemaphoreCounterValueKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_semaphore_counter_value_khr + } else { + ::std::mem::transmute(val) + } + }, + wait_semaphores_khr: unsafe { + unsafe extern "system" fn wait_semaphores_khr( + _device: Device, + _p_wait_info: *const SemaphoreWaitInfo, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_semaphores_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphoresKHR\0"); + let val = _f(cname); + if val.is_null() { + wait_semaphores_khr + } else { + ::std::mem::transmute(val) + } + }, + signal_semaphore_khr: unsafe { + unsafe extern "system" fn signal_semaphore_khr( + _device: Device, + _p_signal_info: *const SemaphoreSignalInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(signal_semaphore_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphoreKHR\0"); + let val = _f(cname); + if val.is_null() { + signal_semaphore_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_timeline_semaphore'"] +impl SemaphoreType { + pub const BINARY_KHR: Self = Self::BINARY; + pub const TIMELINE_KHR: Self = Self::TIMELINE; +} +#[doc = "Generated from 'VK_KHR_timeline_semaphore'"] +impl SemaphoreWaitFlags { + pub const ANY_KHR: Self = Self::ANY; +} +#[doc = "Generated from 'VK_KHR_timeline_semaphore'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; + pub const SEMAPHORE_TYPE_CREATE_INFO_KHR: Self = Self::SEMAPHORE_TYPE_CREATE_INFO; + pub const TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::TIMELINE_SEMAPHORE_SUBMIT_INFO; + pub const SEMAPHORE_WAIT_INFO_KHR: Self = Self::SEMAPHORE_WAIT_INFO; + pub const SEMAPHORE_SIGNAL_INFO_KHR: Self = Self::SEMAPHORE_SIGNAL_INFO; +} +impl KhrExtension209Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_209\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension209Fn {} +unsafe impl Send for KhrExtension209Fn {} +unsafe impl Sync for KhrExtension209Fn {} +impl KhrExtension209Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl IntelShaderIntegerFunctions2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_shader_integer_functions2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct IntelShaderIntegerFunctions2Fn {} +unsafe impl Send for IntelShaderIntegerFunctions2Fn {} +unsafe impl Sync for IntelShaderIntegerFunctions2Fn {} +impl IntelShaderIntegerFunctions2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_INTEL_shader_integer_functions2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self(1_000_209_000); +} +impl IntelPerformanceQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_performance_query\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkInitializePerformanceApiINTEL = unsafe extern "system" fn( + device: Device, + p_initialize_info: *const InitializePerformanceApiInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUninitializePerformanceApiINTEL = unsafe extern "system" fn(device: Device); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceMarkerINTEL = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceMarkerInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceStreamMarkerInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceOverrideINTEL = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_override_info: *const PerformanceOverrideInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquirePerformanceConfigurationINTEL = unsafe extern "system" fn( + device: Device, + p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, + p_configuration: *mut PerformanceConfigurationINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkReleasePerformanceConfigurationINTEL = unsafe extern "system" fn( + device: Device, + configuration: PerformanceConfigurationINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSetPerformanceConfigurationINTEL = + unsafe extern "system" fn(queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPerformanceParameterINTEL = unsafe extern "system" fn( + device: Device, + parameter: PerformanceParameterTypeINTEL, + p_value: *mut PerformanceValueINTEL, +) -> Result; +#[derive(Clone)] +pub struct IntelPerformanceQueryFn { + pub initialize_performance_api_intel: PFN_vkInitializePerformanceApiINTEL, + pub uninitialize_performance_api_intel: PFN_vkUninitializePerformanceApiINTEL, + pub cmd_set_performance_marker_intel: PFN_vkCmdSetPerformanceMarkerINTEL, + pub cmd_set_performance_stream_marker_intel: PFN_vkCmdSetPerformanceStreamMarkerINTEL, + pub cmd_set_performance_override_intel: PFN_vkCmdSetPerformanceOverrideINTEL, + pub acquire_performance_configuration_intel: PFN_vkAcquirePerformanceConfigurationINTEL, + pub release_performance_configuration_intel: PFN_vkReleasePerformanceConfigurationINTEL, + pub queue_set_performance_configuration_intel: PFN_vkQueueSetPerformanceConfigurationINTEL, + pub get_performance_parameter_intel: PFN_vkGetPerformanceParameterINTEL, +} +unsafe impl Send for IntelPerformanceQueryFn {} +unsafe impl Sync for IntelPerformanceQueryFn {} +impl IntelPerformanceQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + initialize_performance_api_intel: unsafe { + unsafe extern "system" fn initialize_performance_api_intel( + _device: Device, + _p_initialize_info: *const InitializePerformanceApiInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(initialize_performance_api_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkInitializePerformanceApiINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + initialize_performance_api_intel + } else { + ::std::mem::transmute(val) + } + }, + uninitialize_performance_api_intel: unsafe { + unsafe extern "system" fn uninitialize_performance_api_intel(_device: Device) { + panic!(concat!( + "Unable to load ", + stringify!(uninitialize_performance_api_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkUninitializePerformanceApiINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + uninitialize_performance_api_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_marker_intel: unsafe { + unsafe extern "system" fn cmd_set_performance_marker_intel( + _command_buffer: CommandBuffer, + _p_marker_info: *const PerformanceMarkerInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_performance_marker_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPerformanceMarkerINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_performance_marker_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_stream_marker_intel: unsafe { + unsafe extern "system" fn cmd_set_performance_stream_marker_intel( + _command_buffer: CommandBuffer, + _p_marker_info: *const PerformanceStreamMarkerInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_performance_stream_marker_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPerformanceStreamMarkerINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_performance_stream_marker_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_override_intel: unsafe { + unsafe extern "system" fn cmd_set_performance_override_intel( + _command_buffer: CommandBuffer, + _p_override_info: *const PerformanceOverrideInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_performance_override_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPerformanceOverrideINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_performance_override_intel + } else { + ::std::mem::transmute(val) + } + }, + acquire_performance_configuration_intel: unsafe { + unsafe extern "system" fn acquire_performance_configuration_intel( + _device: Device, + _p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, + _p_configuration: *mut PerformanceConfigurationINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_performance_configuration_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkAcquirePerformanceConfigurationINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + acquire_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + release_performance_configuration_intel: unsafe { + unsafe extern "system" fn release_performance_configuration_intel( + _device: Device, + _configuration: PerformanceConfigurationINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(release_performance_configuration_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkReleasePerformanceConfigurationINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + release_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + queue_set_performance_configuration_intel: unsafe { + unsafe extern "system" fn queue_set_performance_configuration_intel( + _queue: Queue, + _configuration: PerformanceConfigurationINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(queue_set_performance_configuration_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueSetPerformanceConfigurationINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + queue_set_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + get_performance_parameter_intel: unsafe { + unsafe extern "system" fn get_performance_parameter_intel( + _device: Device, + _parameter: PerformanceParameterTypeINTEL, + _p_value: *mut PerformanceValueINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_performance_parameter_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPerformanceParameterINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + get_performance_parameter_intel + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_INTEL_performance_query'"] +impl ObjectType { + pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1_000_210_000); +} +#[doc = "Generated from 'VK_INTEL_performance_query'"] +impl QueryType { + pub const PERFORMANCE_QUERY_INTEL: Self = Self(1_000_210_000); +} +#[doc = "Generated from 'VK_INTEL_performance_query'"] +impl StructureType { + pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: Self = Self(1_000_210_000); + pub const INITIALIZE_PERFORMANCE_API_INFO_INTEL: Self = Self(1_000_210_001); + pub const PERFORMANCE_MARKER_INFO_INTEL: Self = Self(1_000_210_002); + pub const PERFORMANCE_STREAM_MARKER_INFO_INTEL: Self = Self(1_000_210_003); + pub const PERFORMANCE_OVERRIDE_INFO_INTEL: Self = Self(1_000_210_004); + pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: Self = Self(1_000_210_005); +} +impl KhrVulkanMemoryModelFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_vulkan_memory_model\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct KhrVulkanMemoryModelFn {} +unsafe impl Send for KhrVulkanMemoryModelFn {} +unsafe impl Sync for KhrVulkanMemoryModelFn {} +impl KhrVulkanMemoryModelFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_vulkan_memory_model'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; +} +impl ExtPciBusInfoFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pci_bus_info\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtPciBusInfoFn {} +unsafe impl Send for ExtPciBusInfoFn {} +unsafe impl Sync for ExtPciBusInfoFn {} +impl ExtPciBusInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pci_bus_info'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1_000_212_000); +} +impl AmdDisplayNativeHdrFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_display_native_hdr\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetLocalDimmingAMD = unsafe extern "system" fn( + device: Device, + swap_chain: SwapchainKHR, + local_dimming_enable: Bool32, +); +#[derive(Clone)] +pub struct AmdDisplayNativeHdrFn { + pub set_local_dimming_amd: PFN_vkSetLocalDimmingAMD, +} +unsafe impl Send for AmdDisplayNativeHdrFn {} +unsafe impl Sync for AmdDisplayNativeHdrFn {} +impl AmdDisplayNativeHdrFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_local_dimming_amd: unsafe { + unsafe extern "system" fn set_local_dimming_amd( + _device: Device, + _swap_chain: SwapchainKHR, + _local_dimming_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(set_local_dimming_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetLocalDimmingAMD\0"); + let val = _f(cname); + if val.is_null() { + set_local_dimming_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_AMD_display_native_hdr'"] +impl ColorSpaceKHR { + pub const DISPLAY_NATIVE_AMD: Self = Self(1_000_213_000); +} +#[doc = "Generated from 'VK_AMD_display_native_hdr'"] +impl StructureType { + pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1_000_213_000); + pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: Self = Self(1_000_213_001); +} +impl FuchsiaImagepipeSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_imagepipe_surface\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateImagePipeSurfaceFUCHSIA = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct FuchsiaImagepipeSurfaceFn { + pub create_image_pipe_surface_fuchsia: PFN_vkCreateImagePipeSurfaceFUCHSIA, +} +unsafe impl Send for FuchsiaImagepipeSurfaceFn {} +unsafe impl Sync for FuchsiaImagepipeSurfaceFn {} +impl FuchsiaImagepipeSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_image_pipe_surface_fuchsia: unsafe { + unsafe extern "system" fn create_image_pipe_surface_fuchsia( + _instance: Instance, + _p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_image_pipe_surface_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateImagePipeSurfaceFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + create_image_pipe_surface_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_FUCHSIA_imagepipe_surface'"] +impl StructureType { + pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1_000_214_000); +} +impl KhrShaderTerminateInvocationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_terminate_invocation\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderTerminateInvocationFn {} +unsafe impl Send for KhrShaderTerminateInvocationFn {} +unsafe impl Sync for KhrShaderTerminateInvocationFn {} +impl KhrShaderTerminateInvocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_terminate_invocation'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; +} +impl GoogleExtension217Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_217\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension217Fn {} +unsafe impl Send for GoogleExtension217Fn {} +unsafe impl Sync for GoogleExtension217Fn {} +impl GoogleExtension217Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMetalSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateMetalSurfaceEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const MetalSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtMetalSurfaceFn { + pub create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT, +} +unsafe impl Send for ExtMetalSurfaceFn {} +unsafe impl Sync for ExtMetalSurfaceFn {} +impl ExtMetalSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_metal_surface_ext: unsafe { + unsafe extern "system" fn create_metal_surface_ext( + _instance: Instance, + _p_create_info: *const MetalSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_metal_surface_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMetalSurfaceEXT\0"); + let val = _f(cname); + if val.is_null() { + create_metal_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_metal_surface'"] +impl StructureType { + pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_217_000); +} +impl ExtFragmentDensityMapFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtFragmentDensityMapFn {} +unsafe impl Send for ExtFragmentDensityMapFn {} +unsafe impl Sync for ExtFragmentDensityMapFn {} +impl ExtFragmentDensityMapFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl AccessFlags { + pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl FormatFeatureFlags { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl FormatFeatureFlags2 { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl ImageCreateFlags { + pub const SUBSAMPLED_EXT: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl ImageLayout { + pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1_000_218_000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl ImageUsageFlags { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl ImageViewCreateFlags { + pub const FRAGMENT_DENSITY_MAP_DYNAMIC_EXT: Self = Self(0b1); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl PipelineStageFlags { + pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl SamplerCreateFlags { + pub const SUBSAMPLED_EXT: Self = Self(0b1); + pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1_000_218_000); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1_000_218_001); + pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1_000_218_002); +} +impl ExtExtension220Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_220\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension220Fn {} +unsafe impl Send for ExtExtension220Fn {} +unsafe impl Sync for ExtExtension220Fn {} +impl ExtExtension220Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension221Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_221\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension221Fn {} +unsafe impl Send for KhrExtension221Fn {} +unsafe impl Sync for KhrExtension221Fn {} +impl KhrExtension221Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_extension_221'"] +impl RenderPassCreateFlags { + pub const RESERVED_0_KHR: Self = Self(0b1); +} +impl ExtScalarBlockLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_scalar_block_layout\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtScalarBlockLayoutFn {} +unsafe impl Send for ExtScalarBlockLayoutFn {} +unsafe impl Sync for ExtScalarBlockLayoutFn {} +impl ExtScalarBlockLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_scalar_block_layout'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; +} +impl ExtExtension223Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_223\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension223Fn {} +unsafe impl Send for ExtExtension223Fn {} +unsafe impl Sync for ExtExtension223Fn {} +impl ExtExtension223Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleHlslFunctionality1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_hlsl_functionality1\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct GoogleHlslFunctionality1Fn {} +unsafe impl Send for GoogleHlslFunctionality1Fn {} +unsafe impl Sync for GoogleHlslFunctionality1Fn {} +impl GoogleHlslFunctionality1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleDecorateStringFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_decorate_string\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct GoogleDecorateStringFn {} +unsafe impl Send for GoogleDecorateStringFn {} +unsafe impl Sync for GoogleDecorateStringFn {} +impl GoogleDecorateStringFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtSubgroupSizeControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subgroup_size_control\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtSubgroupSizeControlFn {} +unsafe impl Send for ExtSubgroupSizeControlFn {} +unsafe impl Sync for ExtSubgroupSizeControlFn {} +impl ExtSubgroupSizeControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_subgroup_size_control'"] +impl PipelineShaderStageCreateFlags { + pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self::ALLOW_VARYING_SUBGROUP_SIZE; + pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self::REQUIRE_FULL_SUBGROUPS; +} +#[doc = "Generated from 'VK_EXT_subgroup_size_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; + pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self = + Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; +} +impl KhrFragmentShadingRateFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shading_rate\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_fragment_shading_rate_count: *mut u32, + p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_fragment_size: *const Extent2D, + combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2], +); +#[derive(Clone)] +pub struct KhrFragmentShadingRateFn { + pub get_physical_device_fragment_shading_rates_khr: + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR, + pub cmd_set_fragment_shading_rate_khr: PFN_vkCmdSetFragmentShadingRateKHR, +} +unsafe impl Send for KhrFragmentShadingRateFn {} +unsafe impl Sync for KhrFragmentShadingRateFn {} +impl KhrFragmentShadingRateFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_fragment_shading_rates_khr: unsafe { + unsafe extern "system" fn get_physical_device_fragment_shading_rates_khr( + _physical_device: PhysicalDevice, + _p_fragment_shading_rate_count: *mut u32, + _p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_fragment_shading_rates_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFragmentShadingRatesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_fragment_shading_rates_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_fragment_shading_rate_khr: unsafe { + unsafe extern "system" fn cmd_set_fragment_shading_rate_khr( + _command_buffer: CommandBuffer, + _p_fragment_size: *const Extent2D, + _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2], + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_fragment_shading_rate_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetFragmentShadingRateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_fragment_shading_rate_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl AccessFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self = + Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl DynamicState { + pub const FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl FormatFeatureFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl FormatFeatureFlags2 { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl ImageLayout { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1_000_164_003); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl ImageUsageFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl PipelineStageFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl StructureType { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_226_000); + pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: Self = Self(1_000_226_001); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: Self = Self(1_000_226_002); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: Self = Self(1_000_226_003); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_004); +} +impl AmdShaderCoreProperties2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderCoreProperties2Fn {} +unsafe impl Send for AmdShaderCoreProperties2Fn {} +unsafe impl Sync for AmdShaderCoreProperties2Fn {} +impl AmdShaderCoreProperties2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_shader_core_properties2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1_000_227_000); +} +impl AmdExtension229Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_229\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension229Fn {} +unsafe impl Send for AmdExtension229Fn {} +unsafe impl Sync for AmdExtension229Fn {} +impl AmdExtension229Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdDeviceCoherentMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_device_coherent_memory\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdDeviceCoherentMemoryFn {} +unsafe impl Send for AmdDeviceCoherentMemoryFn {} +unsafe impl Sync for AmdDeviceCoherentMemoryFn {} +impl AmdDeviceCoherentMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_device_coherent_memory'"] +impl MemoryPropertyFlags { + pub const DEVICE_COHERENT_AMD: Self = Self(0b100_0000); + pub const DEVICE_UNCACHED_AMD: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_AMD_device_coherent_memory'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1_000_229_000); +} +impl AmdExtension231Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_231\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension231Fn {} +unsafe impl Send for AmdExtension231Fn {} +unsafe impl Sync for AmdExtension231Fn {} +impl AmdExtension231Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension232Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_232\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension232Fn {} +unsafe impl Send for AmdExtension232Fn {} +unsafe impl Sync for AmdExtension232Fn {} +impl AmdExtension232Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension233Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_233\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension233Fn {} +unsafe impl Send for AmdExtension233Fn {} +unsafe impl Sync for AmdExtension233Fn {} +impl AmdExtension233Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension234Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_234\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension234Fn {} +unsafe impl Send for AmdExtension234Fn {} +unsafe impl Sync for AmdExtension234Fn {} +impl AmdExtension234Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderImageAtomicInt64Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_image_atomic_int64\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderImageAtomicInt64Fn {} +unsafe impl Send for ExtShaderImageAtomicInt64Fn {} +unsafe impl Sync for ExtShaderImageAtomicInt64Fn {} +impl ExtShaderImageAtomicInt64Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_shader_image_atomic_int64'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: Self = Self(1_000_234_000); +} +impl AmdExtension236Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_236\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension236Fn {} +unsafe impl Send for AmdExtension236Fn {} +unsafe impl Sync for AmdExtension236Fn {} +impl AmdExtension236Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSpirv14Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_spirv_1_4\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrSpirv14Fn {} +unsafe impl Send for KhrSpirv14Fn {} +unsafe impl Sync for KhrSpirv14Fn {} +impl KhrSpirv14Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMemoryBudgetFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_budget\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtMemoryBudgetFn {} +unsafe impl Send for ExtMemoryBudgetFn {} +unsafe impl Sync for ExtMemoryBudgetFn {} +impl ExtMemoryBudgetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_memory_budget'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1_000_237_000); +} +impl ExtMemoryPriorityFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_priority\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtMemoryPriorityFn {} +unsafe impl Send for ExtMemoryPriorityFn {} +unsafe impl Sync for ExtMemoryPriorityFn {} +impl ExtMemoryPriorityFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_memory_priority'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1_000_238_000); + pub const MEMORY_PRIORITY_ALLOCATE_INFO_EXT: Self = Self(1_000_238_001); +} +impl KhrSurfaceProtectedCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_surface_protected_capabilities\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrSurfaceProtectedCapabilitiesFn {} +unsafe impl Send for KhrSurfaceProtectedCapabilitiesFn {} +unsafe impl Sync for KhrSurfaceProtectedCapabilitiesFn {} +impl KhrSurfaceProtectedCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_surface_protected_capabilities'"] +impl StructureType { + pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1_000_239_000); +} +impl NvDedicatedAllocationImageAliasingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_dedicated_allocation_image_aliasing\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvDedicatedAllocationImageAliasingFn {} +unsafe impl Send for NvDedicatedAllocationImageAliasingFn {} +unsafe impl Sync for NvDedicatedAllocationImageAliasingFn {} +impl NvDedicatedAllocationImageAliasingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_dedicated_allocation_image_aliasing'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: Self = + Self(1_000_240_000); +} +impl KhrSeparateDepthStencilLayoutsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_separate_depth_stencil_layouts\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrSeparateDepthStencilLayoutsFn {} +unsafe impl Send for KhrSeparateDepthStencilLayoutsFn {} +unsafe impl Sync for KhrSeparateDepthStencilLayoutsFn {} +impl KhrSeparateDepthStencilLayoutsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"] +impl ImageLayout { + pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = Self::DEPTH_ATTACHMENT_OPTIMAL; + pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = Self::DEPTH_READ_ONLY_OPTIMAL; + pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = Self::STENCIL_ATTACHMENT_OPTIMAL; + pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = Self::STENCIL_READ_ONLY_OPTIMAL; +} +#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: Self = + Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT; + pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: Self = + Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; +} +impl IntelExtension243Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_243\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct IntelExtension243Fn {} +unsafe impl Send for IntelExtension243Fn {} +unsafe impl Sync for IntelExtension243Fn {} +impl IntelExtension243Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_INTEL_extension_243'"] +impl AccessFlags2 { + pub const RESERVED_46_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +impl MesaExtension244Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_244\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct MesaExtension244Fn {} +unsafe impl Send for MesaExtension244Fn {} +unsafe impl Sync for MesaExtension244Fn {} +impl MesaExtension244Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtBufferDeviceAddressFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_buffer_device_address\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferDeviceAddress = unsafe extern "system" fn( + device: Device, + p_info: *const BufferDeviceAddressInfo, +) -> DeviceAddress; +#[derive(Clone)] +pub struct ExtBufferDeviceAddressFn { + pub get_buffer_device_address_ext: PFN_vkGetBufferDeviceAddress, +} +unsafe impl Send for ExtBufferDeviceAddressFn {} +unsafe impl Sync for ExtBufferDeviceAddressFn {} +impl ExtBufferDeviceAddressFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_buffer_device_address_ext: unsafe { + unsafe extern "system" fn get_buffer_device_address_ext( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_device_address_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferDeviceAddressEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_device_address_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_buffer_device_address'"] +impl BufferCreateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_EXT: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from 'VK_EXT_buffer_device_address'"] +impl BufferUsageFlags { + pub const SHADER_DEVICE_ADDRESS_EXT: Self = Self::SHADER_DEVICE_ADDRESS; +} +#[doc = "Generated from 'VK_EXT_buffer_device_address'"] +impl Result { + pub const ERROR_INVALID_DEVICE_ADDRESS_EXT: Self = Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS; +} +#[doc = "Generated from 'VK_EXT_buffer_device_address'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1_000_244_000); + pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = Self::BUFFER_DEVICE_ADDRESS_INFO; + pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1_000_244_002); +} +impl ExtToolingInfoFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_tooling_info\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_tool_count: *mut u32, + p_tool_properties: *mut PhysicalDeviceToolProperties, +) -> Result; +#[derive(Clone)] +pub struct ExtToolingInfoFn { + pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolProperties, +} +unsafe impl Send for ExtToolingInfoFn {} +unsafe impl Sync for ExtToolingInfoFn {} +impl ExtToolingInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_tool_properties_ext: unsafe { + unsafe extern "system" fn get_physical_device_tool_properties_ext( + _physical_device: PhysicalDevice, + _p_tool_count: *mut u32, + _p_tool_properties: *mut PhysicalDeviceToolProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_tool_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceToolPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_tool_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_tooling_info'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self::PHYSICAL_DEVICE_TOOL_PROPERTIES; +} +#[doc = "Generated from 'VK_EXT_tooling_info'"] +impl ToolPurposeFlags { + pub const DEBUG_REPORTING_EXT: Self = Self(0b10_0000); + pub const DEBUG_MARKERS_EXT: Self = Self(0b100_0000); +} +impl ExtSeparateStencilUsageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_separate_stencil_usage\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtSeparateStencilUsageFn {} +unsafe impl Send for ExtSeparateStencilUsageFn {} +unsafe impl Sync for ExtSeparateStencilUsageFn {} +impl ExtSeparateStencilUsageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_separate_stencil_usage'"] +impl StructureType { + pub const IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: Self = Self::IMAGE_STENCIL_USAGE_CREATE_INFO; +} +impl ExtValidationFeaturesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_features\0") } + } + pub const SPEC_VERSION: u32 = 5u32; +} +#[derive(Clone)] +pub struct ExtValidationFeaturesFn {} +unsafe impl Send for ExtValidationFeaturesFn {} +unsafe impl Sync for ExtValidationFeaturesFn {} +impl ExtValidationFeaturesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_validation_features'"] +impl StructureType { + pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000); +} +impl KhrPresentWaitFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_wait\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkWaitForPresentKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + present_id: u64, + timeout: u64, +) -> Result; +#[derive(Clone)] +pub struct KhrPresentWaitFn { + pub wait_for_present_khr: PFN_vkWaitForPresentKHR, +} +unsafe impl Send for KhrPresentWaitFn {} +unsafe impl Sync for KhrPresentWaitFn {} +impl KhrPresentWaitFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + wait_for_present_khr: unsafe { + unsafe extern "system" fn wait_for_present_khr( + _device: Device, + _swapchain: SwapchainKHR, + _present_id: u64, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_for_present_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForPresentKHR\0"); + let val = _f(cname); + if val.is_null() { + wait_for_present_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_present_wait'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1_000_248_000); +} +impl NvCooperativeMatrixFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_cooperative_matrix\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut CooperativeMatrixPropertiesNV, +) + -> Result; +#[derive(Clone)] +pub struct NvCooperativeMatrixFn { + pub get_physical_device_cooperative_matrix_properties_nv: + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, +} +unsafe impl Send for NvCooperativeMatrixFn {} +unsafe impl Sync for NvCooperativeMatrixFn {} +impl NvCooperativeMatrixFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_cooperative_matrix_properties_nv: unsafe { + unsafe extern "system" fn get_physical_device_cooperative_matrix_properties_nv( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut CooperativeMatrixPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_cooperative_matrix_properties_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_cooperative_matrix_properties_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_cooperative_matrix'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1_000_249_000); + pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_001); + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_002); +} +impl NvCoverageReductionModeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_coverage_reduction_mode\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_combination_count: *mut u32, + p_combinations: *mut FramebufferMixedSamplesCombinationNV, + ) -> Result; +#[derive(Clone)] +pub struct NvCoverageReductionModeFn { + pub get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, +} +unsafe impl Send for NvCoverageReductionModeFn {} +unsafe impl Sync for NvCoverageReductionModeFn {} +impl NvCoverageReductionModeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: unsafe { + unsafe extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv( + _physical_device: PhysicalDevice, + _p_combination_count: *mut u32, + _p_combinations: *mut FramebufferMixedSamplesCombinationNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!( + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv + ) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_coverage_reduction_mode'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self(1_000_250_000); + pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: Self = Self(1_000_250_001); + pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: Self = Self(1_000_250_002); +} +impl ExtFragmentShaderInterlockFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_shader_interlock\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtFragmentShaderInterlockFn {} +unsafe impl Send for ExtFragmentShaderInterlockFn {} +unsafe impl Sync for ExtFragmentShaderInterlockFn {} +impl ExtFragmentShaderInterlockFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_fragment_shader_interlock'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self(1_000_251_000); +} +impl ExtYcbcrImageArraysFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_image_arrays\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtYcbcrImageArraysFn {} +unsafe impl Send for ExtYcbcrImageArraysFn {} +unsafe impl Sync for ExtYcbcrImageArraysFn {} +impl ExtYcbcrImageArraysFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_ycbcr_image_arrays'"] +impl StructureType { + pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1_000_252_000); +} +impl KhrUniformBufferStandardLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_uniform_buffer_standard_layout\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrUniformBufferStandardLayoutFn {} +unsafe impl Send for KhrUniformBufferStandardLayoutFn {} +unsafe impl Sync for KhrUniformBufferStandardLayoutFn {} +impl KhrUniformBufferStandardLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_uniform_buffer_standard_layout'"] +impl StructureType { + pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; +} +impl ExtProvokingVertexFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_provoking_vertex\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtProvokingVertexFn {} +unsafe impl Send for ExtProvokingVertexFn {} +unsafe impl Sync for ExtProvokingVertexFn {} +impl ExtProvokingVertexFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_provoking_vertex'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: Self = Self(1_000_254_000); + pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: Self = + Self(1_000_254_001); + pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: Self = Self(1_000_254_002); +} +impl ExtFullScreenExclusiveFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_full_screen_exclusive\0") + } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_present_mode_count: *mut u32, + p_present_modes: *mut PresentModeKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireFullScreenExclusiveModeEXT = + unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseFullScreenExclusiveModeEXT = + unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupSurfacePresentModes2EXT = unsafe extern "system" fn( + device: Device, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtFullScreenExclusiveFn { + pub get_physical_device_surface_present_modes2_ext: + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT, + pub acquire_full_screen_exclusive_mode_ext: PFN_vkAcquireFullScreenExclusiveModeEXT, + pub release_full_screen_exclusive_mode_ext: PFN_vkReleaseFullScreenExclusiveModeEXT, + pub get_device_group_surface_present_modes2_ext: PFN_vkGetDeviceGroupSurfacePresentModes2EXT, +} +unsafe impl Send for ExtFullScreenExclusiveFn {} +unsafe impl Sync for ExtFullScreenExclusiveFn {} +impl ExtFullScreenExclusiveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_surface_present_modes2_ext: unsafe { + unsafe extern "system" fn get_physical_device_surface_present_modes2_ext( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_present_mode_count: *mut u32, + _p_present_modes: *mut PresentModeKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_present_modes2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfacePresentModes2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_present_modes2_ext + } else { + ::std::mem::transmute(val) + } + }, + acquire_full_screen_exclusive_mode_ext: unsafe { + unsafe extern "system" fn acquire_full_screen_exclusive_mode_ext( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_full_screen_exclusive_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkAcquireFullScreenExclusiveModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + acquire_full_screen_exclusive_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + release_full_screen_exclusive_mode_ext: unsafe { + unsafe extern "system" fn release_full_screen_exclusive_mode_ext( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(release_full_screen_exclusive_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkReleaseFullScreenExclusiveModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + release_full_screen_exclusive_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_surface_present_modes2_ext: unsafe { + unsafe extern "system" fn get_device_group_surface_present_modes2_ext( + _device: Device, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupSurfacePresentModes2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_surface_present_modes2_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"] +impl Result { + pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1_000_255_000); +} +#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"] +impl StructureType { + pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1_000_255_000); + pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1_000_255_002); + pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: Self = Self(1_000_255_001); +} +impl ExtHeadlessSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_headless_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateHeadlessSurfaceEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const HeadlessSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtHeadlessSurfaceFn { + pub create_headless_surface_ext: PFN_vkCreateHeadlessSurfaceEXT, +} +unsafe impl Send for ExtHeadlessSurfaceFn {} +unsafe impl Sync for ExtHeadlessSurfaceFn {} +impl ExtHeadlessSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_headless_surface_ext: unsafe { + unsafe extern "system" fn create_headless_surface_ext( + _instance: Instance, + _p_create_info: *const HeadlessSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_headless_surface_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateHeadlessSurfaceEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_headless_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_headless_surface'"] +impl StructureType { + pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_256_000); +} +impl KhrBufferDeviceAddressFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_buffer_device_address\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferOpaqueCaptureAddress = + unsafe extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, +) -> u64; +#[derive(Clone)] +pub struct KhrBufferDeviceAddressFn { + pub get_buffer_device_address_khr: crate::vk::PFN_vkGetBufferDeviceAddress, + pub get_buffer_opaque_capture_address_khr: PFN_vkGetBufferOpaqueCaptureAddress, + pub get_device_memory_opaque_capture_address_khr: PFN_vkGetDeviceMemoryOpaqueCaptureAddress, +} +unsafe impl Send for KhrBufferDeviceAddressFn {} +unsafe impl Sync for KhrBufferDeviceAddressFn {} +impl KhrBufferDeviceAddressFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_buffer_device_address_khr: unsafe { + unsafe extern "system" fn get_buffer_device_address_khr( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_device_address_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferDeviceAddressKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_device_address_khr + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_address_khr: unsafe { + unsafe extern "system" fn get_buffer_opaque_capture_address_khr( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_address_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferOpaqueCaptureAddressKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_opaque_capture_address_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_memory_opaque_capture_address_khr: unsafe { + unsafe extern "system" fn get_device_memory_opaque_capture_address_khr( + _device: Device, + _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_device_memory_opaque_capture_address_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMemoryOpaqueCaptureAddressKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_memory_opaque_capture_address_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl BufferCreateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl BufferUsageFlags { + pub const SHADER_DEVICE_ADDRESS_KHR: Self = Self::SHADER_DEVICE_ADDRESS; +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl MemoryAllocateFlags { + pub const DEVICE_ADDRESS_KHR: Self = Self::DEVICE_ADDRESS; + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl Result { + pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: Self = + Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS; +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = Self::BUFFER_DEVICE_ADDRESS_INFO; + pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self = + Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self = + Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; + pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self = + Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; +} +impl ExtExtension259Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_259\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension259Fn {} +unsafe impl Send for ExtExtension259Fn {} +unsafe impl Sync for ExtExtension259Fn {} +impl ExtExtension259Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_259'"] +impl FormatFeatureFlags2 { + pub const RESERVED_44_EXT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESERVED_45_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_extension_259'"] +impl ImageCreateFlags { + pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_extension_259'"] +impl QueueFlags { + pub const RESERVED_9_EXT: Self = Self(0b10_0000_0000); +} +impl ExtLineRasterizationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_line_rasterization\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineStippleEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + line_stipple_factor: u32, + line_stipple_pattern: u16, +); +#[derive(Clone)] +pub struct ExtLineRasterizationFn { + pub cmd_set_line_stipple_ext: PFN_vkCmdSetLineStippleEXT, +} +unsafe impl Send for ExtLineRasterizationFn {} +unsafe impl Sync for ExtLineRasterizationFn {} +impl ExtLineRasterizationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_line_stipple_ext: unsafe { + unsafe extern "system" fn cmd_set_line_stipple_ext( + _command_buffer: CommandBuffer, + _line_stipple_factor: u32, + _line_stipple_pattern: u16, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_stipple_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_line_stipple_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_line_rasterization'"] +impl DynamicState { + pub const LINE_STIPPLE_EXT: Self = Self(1_000_259_000); +} +#[doc = "Generated from 'VK_EXT_line_rasterization'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1_000_259_000); + pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: Self = Self(1_000_259_001); + pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_259_002); +} +impl ExtShaderAtomicFloatFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderAtomicFloatFn {} +unsafe impl Send for ExtShaderAtomicFloatFn {} +unsafe impl Sync for ExtShaderAtomicFloatFn {} +impl ExtShaderAtomicFloatFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_shader_atomic_float'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: Self = Self(1_000_260_000); +} +impl ExtHostQueryResetFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_host_query_reset\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkResetQueryPool = unsafe extern "system" fn( + device: Device, + query_pool: QueryPool, + first_query: u32, + query_count: u32, +); +#[derive(Clone)] +pub struct ExtHostQueryResetFn { + pub reset_query_pool_ext: PFN_vkResetQueryPool, +} +unsafe impl Send for ExtHostQueryResetFn {} +unsafe impl Sync for ExtHostQueryResetFn {} +impl ExtHostQueryResetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + reset_query_pool_ext: unsafe { + unsafe extern "system" fn reset_query_pool_ext( + _device: Device, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + ) { + panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPoolEXT\0"); + let val = _f(cname); + if val.is_null() { + reset_query_pool_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_host_query_reset'"] +impl StructureType { + pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; +} +impl GgpExtension263Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_263\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension263Fn {} +unsafe impl Send for GgpExtension263Fn {} +unsafe impl Sync for GgpExtension263Fn {} +impl GgpExtension263Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl BrcmExtension264Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_264\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct BrcmExtension264Fn {} +unsafe impl Send for BrcmExtension264Fn {} +unsafe impl Sync for BrcmExtension264Fn {} +impl BrcmExtension264Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl BrcmExtension265Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_265\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct BrcmExtension265Fn {} +unsafe impl Send for BrcmExtension265Fn {} +unsafe impl Sync for BrcmExtension265Fn {} +impl BrcmExtension265Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtIndexTypeUint8Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_index_type_uint8\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtIndexTypeUint8Fn {} +unsafe impl Send for ExtIndexTypeUint8Fn {} +unsafe impl Sync for ExtIndexTypeUint8Fn {} +impl ExtIndexTypeUint8Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_index_type_uint8'"] +impl IndexType { + pub const UINT8_EXT: Self = Self(1_000_265_000); +} +#[doc = "Generated from 'VK_EXT_index_type_uint8'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1_000_265_000); +} +impl ExtExtension267Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_267\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension267Fn {} +unsafe impl Send for ExtExtension267Fn {} +unsafe impl Sync for ExtExtension267Fn {} +impl ExtExtension267Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtendedDynamicStateFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCullMode = + unsafe extern "system" fn(command_buffer: CommandBuffer, cull_mode: CullModeFlags); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetFrontFace = + unsafe extern "system" fn(command_buffer: CommandBuffer, front_face: FrontFace); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPrimitiveTopology = + unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_topology: PrimitiveTopology); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportWithCount = unsafe extern "system" fn( + command_buffer: CommandBuffer, + viewport_count: u32, + p_viewports: *const Viewport, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetScissorWithCount = unsafe extern "system" fn( + command_buffer: CommandBuffer, + scissor_count: u32, + p_scissors: *const Rect2D, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindVertexBuffers2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_binding: u32, + binding_count: u32, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + p_sizes: *const DeviceSize, + p_strides: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthTestEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_test_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthWriteEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_write_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthCompareOp = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_compare_op: CompareOp); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBoundsTestEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bounds_test_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilTestEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, stencil_test_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilOp = unsafe extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + fail_op: StencilOp, + pass_op: StencilOp, + depth_fail_op: StencilOp, + compare_op: CompareOp, +); +#[derive(Clone)] +pub struct ExtExtendedDynamicStateFn { + pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode, + pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace, + pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology, + pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount, + pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount, + pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2, + pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable, + pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable, + pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp, + pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable, + pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable, + pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp, +} +unsafe impl Send for ExtExtendedDynamicStateFn {} +unsafe impl Sync for ExtExtendedDynamicStateFn {} +impl ExtExtendedDynamicStateFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_cull_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_cull_mode_ext( + _command_buffer: CommandBuffer, + _cull_mode: CullModeFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_cull_mode_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_cull_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_front_face_ext: unsafe { + unsafe extern "system" fn cmd_set_front_face_ext( + _command_buffer: CommandBuffer, + _front_face: FrontFace, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_front_face_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_front_face_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_topology_ext: unsafe { + unsafe extern "system" fn cmd_set_primitive_topology_ext( + _command_buffer: CommandBuffer, + _primitive_topology: PrimitiveTopology, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_topology_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveTopologyEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_topology_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_with_count_ext: unsafe { + unsafe extern "system" fn cmd_set_viewport_with_count_ext( + _command_buffer: CommandBuffer, + _viewport_count: u32, + _p_viewports: *const Viewport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_with_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWithCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_with_count_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_scissor_with_count_ext: unsafe { + unsafe extern "system" fn cmd_set_scissor_with_count_ext( + _command_buffer: CommandBuffer, + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_scissor_with_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetScissorWithCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_scissor_with_count_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_vertex_buffers2_ext: unsafe { + unsafe extern "system" fn cmd_bind_vertex_buffers2_ext( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + _p_sizes: *const DeviceSize, + _p_strides: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_vertex_buffers2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindVertexBuffers2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_vertex_buffers2_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_test_enable_ext( + _command_buffer: CommandBuffer, + _depth_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_write_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_write_enable_ext( + _command_buffer: CommandBuffer, + _depth_write_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_write_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthWriteEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_write_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_compare_op_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_compare_op_ext( + _command_buffer: CommandBuffer, + _depth_compare_op: CompareOp, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_compare_op_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_compare_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bounds_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext( + _command_buffer: CommandBuffer, + _depth_bounds_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bounds_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBoundsTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bounds_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_stencil_test_enable_ext( + _command_buffer: CommandBuffer, + _stencil_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetStencilTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_op_ext: unsafe { + unsafe extern "system" fn cmd_set_stencil_op_ext( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _fail_op: StencilOp, + _pass_op: StencilOp, + _depth_fail_op: StencilOp, + _compare_op: CompareOp, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_op_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_op_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"] +impl DynamicState { + pub const CULL_MODE_EXT: Self = Self::CULL_MODE; + pub const FRONT_FACE_EXT: Self = Self::FRONT_FACE; + pub const PRIMITIVE_TOPOLOGY_EXT: Self = Self::PRIMITIVE_TOPOLOGY; + pub const VIEWPORT_WITH_COUNT_EXT: Self = Self::VIEWPORT_WITH_COUNT; + pub const SCISSOR_WITH_COUNT_EXT: Self = Self::SCISSOR_WITH_COUNT; + pub const VERTEX_INPUT_BINDING_STRIDE_EXT: Self = Self::VERTEX_INPUT_BINDING_STRIDE; + pub const DEPTH_TEST_ENABLE_EXT: Self = Self::DEPTH_TEST_ENABLE; + pub const DEPTH_WRITE_ENABLE_EXT: Self = Self::DEPTH_WRITE_ENABLE; + pub const DEPTH_COMPARE_OP_EXT: Self = Self::DEPTH_COMPARE_OP; + pub const DEPTH_BOUNDS_TEST_ENABLE_EXT: Self = Self::DEPTH_BOUNDS_TEST_ENABLE; + pub const STENCIL_TEST_ENABLE_EXT: Self = Self::STENCIL_TEST_ENABLE; + pub const STENCIL_OP_EXT: Self = Self::STENCIL_OP; +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"] +impl StructureType { + #[doc = "Not promoted to 1.3"] + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_267_000); +} +impl KhrDeferredHostOperationsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_deferred_host_operations\0") + } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDeferredOperationKHR = unsafe extern "system" fn( + device: Device, + p_allocator: *const AllocationCallbacks, + p_deferred_operation: *mut DeferredOperationKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDeferredOperationKHR = unsafe extern "system" fn( + device: Device, + operation: DeferredOperationKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR = + unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> u32; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeferredOperationResultKHR = + unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDeferredOperationJoinKHR = + unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result; +#[derive(Clone)] +pub struct KhrDeferredHostOperationsFn { + pub create_deferred_operation_khr: PFN_vkCreateDeferredOperationKHR, + pub destroy_deferred_operation_khr: PFN_vkDestroyDeferredOperationKHR, + pub get_deferred_operation_max_concurrency_khr: PFN_vkGetDeferredOperationMaxConcurrencyKHR, + pub get_deferred_operation_result_khr: PFN_vkGetDeferredOperationResultKHR, + pub deferred_operation_join_khr: PFN_vkDeferredOperationJoinKHR, +} +unsafe impl Send for KhrDeferredHostOperationsFn {} +unsafe impl Sync for KhrDeferredHostOperationsFn {} +impl KhrDeferredHostOperationsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_deferred_operation_khr: unsafe { + unsafe extern "system" fn create_deferred_operation_khr( + _device: Device, + _p_allocator: *const AllocationCallbacks, + _p_deferred_operation: *mut DeferredOperationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_deferred_operation_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDeferredOperationKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_deferred_operation_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_deferred_operation_khr: unsafe { + unsafe extern "system" fn destroy_deferred_operation_khr( + _device: Device, + _operation: DeferredOperationKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_deferred_operation_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDeferredOperationKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_deferred_operation_khr + } else { + ::std::mem::transmute(val) + } + }, + get_deferred_operation_max_concurrency_khr: unsafe { + unsafe extern "system" fn get_deferred_operation_max_concurrency_khr( + _device: Device, + _operation: DeferredOperationKHR, + ) -> u32 { + panic!(concat!( + "Unable to load ", + stringify!(get_deferred_operation_max_concurrency_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeferredOperationMaxConcurrencyKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_deferred_operation_max_concurrency_khr + } else { + ::std::mem::transmute(val) + } + }, + get_deferred_operation_result_khr: unsafe { + unsafe extern "system" fn get_deferred_operation_result_khr( + _device: Device, + _operation: DeferredOperationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_deferred_operation_result_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeferredOperationResultKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_deferred_operation_result_khr + } else { + ::std::mem::transmute(val) + } + }, + deferred_operation_join_khr: unsafe { + unsafe extern "system" fn deferred_operation_join_khr( + _device: Device, + _operation: DeferredOperationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(deferred_operation_join_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDeferredOperationJoinKHR\0", + ); + let val = _f(cname); + if val.is_null() { + deferred_operation_join_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_deferred_host_operations'"] +impl ObjectType { + pub const DEFERRED_OPERATION_KHR: Self = Self(1_000_268_000); +} +#[doc = "Generated from 'VK_KHR_deferred_host_operations'"] +impl Result { + pub const THREAD_IDLE_KHR: Self = Self(1_000_268_000); + pub const THREAD_DONE_KHR: Self = Self(1_000_268_001); + pub const OPERATION_DEFERRED_KHR: Self = Self(1_000_268_002); + pub const OPERATION_NOT_DEFERRED_KHR: Self = Self(1_000_268_003); +} +impl KhrPipelineExecutablePropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_pipeline_executable_properties\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutablePropertiesKHR = unsafe extern "system" fn( + device: Device, + p_pipeline_info: *const PipelineInfoKHR, + p_executable_count: *mut u32, + p_properties: *mut PipelineExecutablePropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutableStatisticsKHR = unsafe extern "system" fn( + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_statistic_count: *mut u32, + p_statistics: *mut PipelineExecutableStatisticKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR = + unsafe extern "system" fn( + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_internal_representation_count: *mut u32, + p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, + ) -> Result; +#[derive(Clone)] +pub struct KhrPipelineExecutablePropertiesFn { + pub get_pipeline_executable_properties_khr: PFN_vkGetPipelineExecutablePropertiesKHR, + pub get_pipeline_executable_statistics_khr: PFN_vkGetPipelineExecutableStatisticsKHR, + pub get_pipeline_executable_internal_representations_khr: + PFN_vkGetPipelineExecutableInternalRepresentationsKHR, +} +unsafe impl Send for KhrPipelineExecutablePropertiesFn {} +unsafe impl Sync for KhrPipelineExecutablePropertiesFn {} +impl KhrPipelineExecutablePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_pipeline_executable_properties_khr: unsafe { + unsafe extern "system" fn get_pipeline_executable_properties_khr( + _device: Device, + _p_pipeline_info: *const PipelineInfoKHR, + _p_executable_count: *mut u32, + _p_properties: *mut PipelineExecutablePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelineExecutablePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_executable_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_executable_statistics_khr: unsafe { + unsafe extern "system" fn get_pipeline_executable_statistics_khr( + _device: Device, + _p_executable_info: *const PipelineExecutableInfoKHR, + _p_statistic_count: *mut u32, + _p_statistics: *mut PipelineExecutableStatisticKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_statistics_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelineExecutableStatisticsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_executable_statistics_khr + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_executable_internal_representations_khr: unsafe { + unsafe extern "system" fn get_pipeline_executable_internal_representations_khr( + _device: Device, + _p_executable_info: *const PipelineExecutableInfoKHR, + _p_internal_representation_count: *mut u32, + _p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_internal_representations_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelineExecutableInternalRepresentationsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_executable_internal_representations_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"] +impl PipelineCreateFlags { + pub const CAPTURE_STATISTICS_KHR: Self = Self(0b100_0000); + pub const CAPTURE_INTERNAL_REPRESENTATIONS_KHR: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self = + Self(1_000_269_000); + pub const PIPELINE_INFO_KHR: Self = Self(1_000_269_001); + pub const PIPELINE_EXECUTABLE_PROPERTIES_KHR: Self = Self(1_000_269_002); + pub const PIPELINE_EXECUTABLE_INFO_KHR: Self = Self(1_000_269_003); + pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1_000_269_004); + pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1_000_269_005); +} +impl IntelExtension271Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_271\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct IntelExtension271Fn {} +unsafe impl Send for IntelExtension271Fn {} +unsafe impl Sync for IntelExtension271Fn {} +impl IntelExtension271Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_INTEL_extension_271'"] +impl ImageUsageFlags { + pub const RESERVED_22_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); +} +impl IntelExtension272Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_272\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct IntelExtension272Fn {} +unsafe impl Send for IntelExtension272Fn {} +unsafe impl Sync for IntelExtension272Fn {} +impl IntelExtension272Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl IntelExtension273Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_273\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct IntelExtension273Fn {} +unsafe impl Send for IntelExtension273Fn {} +unsafe impl Sync for IntelExtension273Fn {} +impl IntelExtension273Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderAtomicFloat2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderAtomicFloat2Fn {} +unsafe impl Send for ExtShaderAtomicFloat2Fn {} +unsafe impl Sync for ExtShaderAtomicFloat2Fn {} +impl ExtShaderAtomicFloat2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_shader_atomic_float2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000); +} +impl ExtSurfaceMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_surface_maintenance1\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtSurfaceMaintenance1Fn {} +unsafe impl Send for ExtSurfaceMaintenance1Fn {} +unsafe impl Sync for ExtSurfaceMaintenance1Fn {} +impl ExtSurfaceMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_surface_maintenance1'"] +impl StructureType { + pub const SURFACE_PRESENT_MODE_EXT: Self = Self(1_000_274_000); + pub const SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: Self = Self(1_000_274_001); + pub const SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: Self = Self(1_000_274_002); +} +impl ExtSwapchainMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_maintenance1\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseSwapchainImagesEXT = unsafe extern "system" fn( + device: Device, + p_release_info: *const ReleaseSwapchainImagesInfoEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtSwapchainMaintenance1Fn { + pub release_swapchain_images_ext: PFN_vkReleaseSwapchainImagesEXT, +} +unsafe impl Send for ExtSwapchainMaintenance1Fn {} +unsafe impl Sync for ExtSwapchainMaintenance1Fn {} +impl ExtSwapchainMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + release_swapchain_images_ext: unsafe { + unsafe extern "system" fn release_swapchain_images_ext( + _device: Device, + _p_release_info: *const ReleaseSwapchainImagesInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(release_swapchain_images_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkReleaseSwapchainImagesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + release_swapchain_images_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: Self = Self(1_000_275_000); + pub const SWAPCHAIN_PRESENT_FENCE_INFO_EXT: Self = Self(1_000_275_001); + pub const SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: Self = Self(1_000_275_002); + pub const SWAPCHAIN_PRESENT_MODE_INFO_EXT: Self = Self(1_000_275_003); + pub const SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: Self = Self(1_000_275_004); + pub const RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: Self = Self(1_000_275_005); +} +#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"] +impl SwapchainCreateFlagsKHR { + pub const DEFERRED_MEMORY_ALLOCATION_EXT: Self = Self(0b1000); +} +impl ExtShaderDemoteToHelperInvocationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_shader_demote_to_helper_invocation\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderDemoteToHelperInvocationFn {} +unsafe impl Send for ExtShaderDemoteToHelperInvocationFn {} +unsafe impl Sync for ExtShaderDemoteToHelperInvocationFn {} +impl ExtShaderDemoteToHelperInvocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_shader_demote_to_helper_invocation'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; +} +impl NvDeviceGeneratedCommandsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_generated_commands\0") + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn( + device: Device, + p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_generated_commands_info: *const GeneratedCommandsInfoNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + is_preprocessed: Bool32, + p_generated_commands_info: *const GeneratedCommandsInfoNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, + group_index: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn( + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNV, + p_allocator: *const AllocationCallbacks, +); +#[derive(Clone)] +pub struct NvDeviceGeneratedCommandsFn { + pub get_generated_commands_memory_requirements_nv: + PFN_vkGetGeneratedCommandsMemoryRequirementsNV, + pub cmd_preprocess_generated_commands_nv: PFN_vkCmdPreprocessGeneratedCommandsNV, + pub cmd_execute_generated_commands_nv: PFN_vkCmdExecuteGeneratedCommandsNV, + pub cmd_bind_pipeline_shader_group_nv: PFN_vkCmdBindPipelineShaderGroupNV, + pub create_indirect_commands_layout_nv: PFN_vkCreateIndirectCommandsLayoutNV, + pub destroy_indirect_commands_layout_nv: PFN_vkDestroyIndirectCommandsLayoutNV, +} +unsafe impl Send for NvDeviceGeneratedCommandsFn {} +unsafe impl Sync for NvDeviceGeneratedCommandsFn {} +impl NvDeviceGeneratedCommandsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_generated_commands_memory_requirements_nv: unsafe { + unsafe extern "system" fn get_generated_commands_memory_requirements_nv( + _device: Device, + _p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_generated_commands_memory_requirements_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetGeneratedCommandsMemoryRequirementsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_generated_commands_memory_requirements_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_preprocess_generated_commands_nv: unsafe { + unsafe extern "system" fn cmd_preprocess_generated_commands_nv( + _command_buffer: CommandBuffer, + _p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_preprocess_generated_commands_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdPreprocessGeneratedCommandsNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_preprocess_generated_commands_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_execute_generated_commands_nv: unsafe { + unsafe extern "system" fn cmd_execute_generated_commands_nv( + _command_buffer: CommandBuffer, + _is_preprocessed: Bool32, + _p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_execute_generated_commands_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdExecuteGeneratedCommandsNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_execute_generated_commands_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_pipeline_shader_group_nv: unsafe { + unsafe extern "system" fn cmd_bind_pipeline_shader_group_nv( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _pipeline: Pipeline, + _group_index: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_pipeline_shader_group_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindPipelineShaderGroupNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_pipeline_shader_group_nv + } else { + ::std::mem::transmute(val) + } + }, + create_indirect_commands_layout_nv: unsafe { + unsafe extern "system" fn create_indirect_commands_layout_nv( + _device: Device, + _p_create_info: *const IndirectCommandsLayoutCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_indirect_commands_layout_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateIndirectCommandsLayoutNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_indirect_commands_layout_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_indirect_commands_layout_nv: unsafe { + unsafe extern "system" fn destroy_indirect_commands_layout_nv( + _device: Device, + _indirect_commands_layout: IndirectCommandsLayoutNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_indirect_commands_layout_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyIndirectCommandsLayoutNV\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_indirect_commands_layout_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl AccessFlags { + pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000); + pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl ObjectType { + pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1_000_277_000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl PipelineCreateFlags { + pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl PipelineStageFlags { + pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1_000_277_000); + pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_277_001); + pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1_000_277_002); + pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1_000_277_003); + pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: Self = Self(1_000_277_004); + pub const GENERATED_COMMANDS_INFO_NV: Self = Self(1_000_277_005); + pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_277_006); + pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: Self = Self(1_000_277_007); +} +impl NvInheritedViewportScissorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_inherited_viewport_scissor\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvInheritedViewportScissorFn {} +unsafe impl Send for NvInheritedViewportScissorFn {} +unsafe impl Sync for NvInheritedViewportScissorFn {} +impl NvInheritedViewportScissorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_inherited_viewport_scissor'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: Self = Self(1_000_278_000); + pub const COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: Self = Self(1_000_278_001); +} +impl KhrExtension280Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_280\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension280Fn {} +unsafe impl Send for KhrExtension280Fn {} +unsafe impl Sync for KhrExtension280Fn {} +impl KhrExtension280Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrShaderIntegerDotProductFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_integer_dot_product\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderIntegerDotProductFn {} +unsafe impl Send for KhrShaderIntegerDotProductFn {} +unsafe impl Sync for KhrShaderIntegerDotProductFn {} +impl KhrShaderIntegerDotProductFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_integer_dot_product'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; +} +impl ExtTexelBufferAlignmentFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_texel_buffer_alignment\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtTexelBufferAlignmentFn {} +unsafe impl Send for ExtTexelBufferAlignmentFn {} +unsafe impl Sync for ExtTexelBufferAlignmentFn {} +impl ExtTexelBufferAlignmentFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_texel_buffer_alignment'"] +impl StructureType { + #[doc = "Not promoted to 1.3"] + pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: Self = Self(1_000_281_000); + pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; +} +impl QcomRenderPassTransformFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_transform\0") + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct QcomRenderPassTransformFn {} +unsafe impl Send for QcomRenderPassTransformFn {} +unsafe impl Sync for QcomRenderPassTransformFn {} +impl QcomRenderPassTransformFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_render_pass_transform'"] +impl RenderPassCreateFlags { + pub const TRANSFORM_QCOM: Self = Self(0b10); +} +#[doc = "Generated from 'VK_QCOM_render_pass_transform'"] +impl StructureType { + pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self = + Self(1_000_282_000); + pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001); +} +impl ExtExtension284Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_284\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension284Fn {} +unsafe impl Send for ExtExtension284Fn {} +unsafe impl Sync for ExtExtension284Fn {} +impl ExtExtension284Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtDeviceMemoryReportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_memory_report\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtDeviceMemoryReportFn {} +unsafe impl Send for ExtDeviceMemoryReportFn {} +unsafe impl Sync for ExtDeviceMemoryReportFn {} +impl ExtDeviceMemoryReportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_device_memory_report'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: Self = Self(1_000_284_000); + pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: Self = Self(1_000_284_001); + pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: Self = Self(1_000_284_002); +} +impl ExtAcquireDrmDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_drm_display\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireDrmDisplayEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + drm_fd: i32, + display: DisplayKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDrmDisplayEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + drm_fd: i32, + connector_id: u32, + display: *mut DisplayKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtAcquireDrmDisplayFn { + pub acquire_drm_display_ext: PFN_vkAcquireDrmDisplayEXT, + pub get_drm_display_ext: PFN_vkGetDrmDisplayEXT, +} +unsafe impl Send for ExtAcquireDrmDisplayFn {} +unsafe impl Sync for ExtAcquireDrmDisplayFn {} +impl ExtAcquireDrmDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + acquire_drm_display_ext: unsafe { + unsafe extern "system" fn acquire_drm_display_ext( + _physical_device: PhysicalDevice, + _drm_fd: i32, + _display: DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_drm_display_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireDrmDisplayEXT\0"); + let val = _f(cname); + if val.is_null() { + acquire_drm_display_ext + } else { + ::std::mem::transmute(val) + } + }, + get_drm_display_ext: unsafe { + unsafe extern "system" fn get_drm_display_ext( + _physical_device: PhysicalDevice, + _drm_fd: i32, + _connector_id: u32, + _display: *mut DisplayKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_drm_display_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDrmDisplayEXT\0"); + let val = _f(cname); + if val.is_null() { + get_drm_display_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtRobustness2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_robustness2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtRobustness2Fn {} +unsafe impl Send for ExtRobustness2Fn {} +unsafe impl Sync for ExtRobustness2Fn {} +impl ExtRobustness2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_robustness2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: Self = Self(1_000_286_000); + pub const PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: Self = Self(1_000_286_001); +} +impl ExtCustomBorderColorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_custom_border_color\0") } + } + pub const SPEC_VERSION: u32 = 12u32; +} +#[derive(Clone)] +pub struct ExtCustomBorderColorFn {} +unsafe impl Send for ExtCustomBorderColorFn {} +unsafe impl Sync for ExtCustomBorderColorFn {} +impl ExtCustomBorderColorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_custom_border_color'"] +impl BorderColor { + pub const FLOAT_CUSTOM_EXT: Self = Self(1_000_287_003); + pub const INT_CUSTOM_EXT: Self = Self(1_000_287_004); +} +#[doc = "Generated from 'VK_EXT_custom_border_color'"] +impl StructureType { + pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: Self = Self(1_000_287_000); + pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: Self = Self(1_000_287_001); + pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: Self = Self(1_000_287_002); +} +impl ExtExtension289Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_289\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension289Fn {} +unsafe impl Send for ExtExtension289Fn {} +unsafe impl Sync for ExtExtension289Fn {} +impl ExtExtension289Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_289'"] +impl Format { + pub const ASTC_3X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_000); + pub const ASTC_3X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_001); + pub const ASTC_3X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_002); + pub const ASTC_4X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_003); + pub const ASTC_4X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_004); + pub const ASTC_4X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_005); + pub const ASTC_4X4X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_006); + pub const ASTC_4X4X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_007); + pub const ASTC_4X4X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_008); + pub const ASTC_4X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_009); + pub const ASTC_4X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_010); + pub const ASTC_4X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_011); + pub const ASTC_5X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_012); + pub const ASTC_5X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_013); + pub const ASTC_5X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_014); + pub const ASTC_5X5X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_015); + pub const ASTC_5X5X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_016); + pub const ASTC_5X5X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_017); + pub const ASTC_5X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_018); + pub const ASTC_5X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_019); + pub const ASTC_5X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_020); + pub const ASTC_6X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_021); + pub const ASTC_6X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_022); + pub const ASTC_6X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_023); + pub const ASTC_6X6X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_024); + pub const ASTC_6X6X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_025); + pub const ASTC_6X6X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_026); + pub const ASTC_6X6X6_UNORM_BLOCK_EXT: Self = Self(1_000_288_027); + pub const ASTC_6X6X6_SRGB_BLOCK_EXT: Self = Self(1_000_288_028); + pub const ASTC_6X6X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_029); +} +impl GoogleUserTypeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_user_type\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct GoogleUserTypeFn {} +unsafe impl Send for GoogleUserTypeFn {} +unsafe impl Sync for GoogleUserTypeFn {} +impl GoogleUserTypeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrPipelineLibraryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_pipeline_library\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrPipelineLibraryFn {} +unsafe impl Send for KhrPipelineLibraryFn {} +unsafe impl Sync for KhrPipelineLibraryFn {} +impl KhrPipelineLibraryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_pipeline_library'"] +impl PipelineCreateFlags { + pub const LIBRARY_KHR: Self = Self(0b1000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_pipeline_library'"] +impl StructureType { + pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1_000_290_000); +} +impl NvExtension292Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_292\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension292Fn {} +unsafe impl Send for NvExtension292Fn {} +unsafe impl Sync for NvExtension292Fn {} +impl NvExtension292Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvPresentBarrierFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_present_barrier\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvPresentBarrierFn {} +unsafe impl Send for NvPresentBarrierFn {} +unsafe impl Sync for NvPresentBarrierFn {} +impl NvPresentBarrierFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_present_barrier'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: Self = Self(1_000_292_000); + pub const SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: Self = Self(1_000_292_001); + pub const SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: Self = Self(1_000_292_002); +} +impl KhrShaderNonSemanticInfoFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_non_semantic_info\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderNonSemanticInfoFn {} +unsafe impl Send for KhrShaderNonSemanticInfoFn {} +unsafe impl Sync for KhrShaderNonSemanticInfoFn {} +impl KhrShaderNonSemanticInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrPresentIdFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_id\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrPresentIdFn {} +unsafe impl Send for KhrPresentIdFn {} +unsafe impl Sync for KhrPresentIdFn {} +impl KhrPresentIdFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_present_id'"] +impl StructureType { + pub const PRESENT_ID_KHR: Self = Self(1_000_294_000); + pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1_000_294_001); +} +impl ExtPrivateDataFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_private_data\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreatePrivateDataSlot = unsafe extern "system" fn( + device: Device, + p_create_info: *const PrivateDataSlotCreateInfo, + p_allocator: *const AllocationCallbacks, + p_private_data_slot: *mut PrivateDataSlot, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyPrivateDataSlot = unsafe extern "system" fn( + device: Device, + private_data_slot: PrivateDataSlot, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkSetPrivateData = unsafe extern "system" fn( + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlot, + data: u64, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPrivateData = unsafe extern "system" fn( + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlot, + p_data: *mut u64, +); +#[derive(Clone)] +pub struct ExtPrivateDataFn { + pub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlot, + pub destroy_private_data_slot_ext: PFN_vkDestroyPrivateDataSlot, + pub set_private_data_ext: PFN_vkSetPrivateData, + pub get_private_data_ext: PFN_vkGetPrivateData, +} +unsafe impl Send for ExtPrivateDataFn {} +unsafe impl Sync for ExtPrivateDataFn {} +impl ExtPrivateDataFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_private_data_slot_ext: unsafe { + unsafe extern "system" fn create_private_data_slot_ext( + _device: Device, + _p_create_info: *const PrivateDataSlotCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_private_data_slot: *mut PrivateDataSlot, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_private_data_slot_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreatePrivateDataSlotEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_private_data_slot_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_private_data_slot_ext: unsafe { + unsafe extern "system" fn destroy_private_data_slot_ext( + _device: Device, + _private_data_slot: PrivateDataSlot, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_private_data_slot_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyPrivateDataSlotEXT\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_private_data_slot_ext + } else { + ::std::mem::transmute(val) + } + }, + set_private_data_ext: unsafe { + unsafe extern "system" fn set_private_data_ext( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlot, + _data: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(set_private_data_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateDataEXT\0"); + let val = _f(cname); + if val.is_null() { + set_private_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_private_data_ext: unsafe { + unsafe extern "system" fn get_private_data_ext( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlot, + _p_data: *mut u64, + ) { + panic!(concat!("Unable to load ", stringify!(get_private_data_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateDataEXT\0"); + let val = _f(cname); + if val.is_null() { + get_private_data_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_private_data'"] +impl ObjectType { + pub const PRIVATE_DATA_SLOT_EXT: Self = Self::PRIVATE_DATA_SLOT; +} +#[doc = "Generated from 'VK_EXT_private_data'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + pub const DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: Self = Self::DEVICE_PRIVATE_DATA_CREATE_INFO; + pub const PRIVATE_DATA_SLOT_CREATE_INFO_EXT: Self = Self::PRIVATE_DATA_SLOT_CREATE_INFO; +} +impl KhrExtension297Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_297\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension297Fn {} +unsafe impl Send for KhrExtension297Fn {} +unsafe impl Sync for KhrExtension297Fn {} +impl KhrExtension297Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_extension_297'"] +impl PipelineShaderStageCreateFlags { + pub const RESERVED_3_KHR: Self = Self(0b1000); +} +impl ExtPipelineCreationCacheControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_pipeline_creation_cache_control\0", + ) + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct ExtPipelineCreationCacheControlFn {} +unsafe impl Send for ExtPipelineCreationCacheControlFn {} +unsafe impl Sync for ExtPipelineCreationCacheControlFn {} +impl ExtPipelineCreationCacheControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"] +impl PipelineCacheCreateFlags { + pub const EXTERNALLY_SYNCHRONIZED_EXT: Self = Self::EXTERNALLY_SYNCHRONIZED; +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"] +impl PipelineCreateFlags { + pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED; + pub const EARLY_RETURN_ON_FAILURE_EXT: Self = Self::EARLY_RETURN_ON_FAILURE; +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"] +impl Result { + pub const PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED; + pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED; +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; +} +impl KhrExtension299Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_299\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension299Fn {} +unsafe impl Send for KhrExtension299Fn {} +unsafe impl Sync for KhrExtension299Fn {} +impl KhrExtension299Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_extension_299'"] +impl MemoryHeapFlags { + pub const RESERVED_2_KHR: Self = Self(0b100); +} +#[doc = "Generated from 'VK_KHR_extension_299'"] +impl PipelineCacheCreateFlags { + pub const RESERVED_1_KHR: Self = Self::RESERVED_1_EXT; + pub const RESERVED_2_KHR: Self = Self(0b100); +} +impl KhrVideoEncodeQueueFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") } + } + pub const SPEC_VERSION: u32 = 7u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_encode_info: *const VideoEncodeInfoKHR, +); +#[derive(Clone)] +pub struct KhrVideoEncodeQueueFn { + pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR, +} +unsafe impl Send for KhrVideoEncodeQueueFn {} +unsafe impl Sync for KhrVideoEncodeQueueFn {} +impl KhrVideoEncodeQueueFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_encode_video_khr: unsafe { + unsafe extern "system" fn cmd_encode_video_khr( + _command_buffer: CommandBuffer, + _p_encode_info: *const VideoEncodeInfoKHR, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_encode_video_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEncodeVideoKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_encode_video_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl AccessFlags2 { + pub const VIDEO_ENCODE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const VIDEO_ENCODE_WRITE_KHR: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl BufferUsageFlags { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b1000_0000_0000_0000); + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl FormatFeatureFlags { + pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl FormatFeatureFlags2 { + pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageLayout { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(1_000_299_000); + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1_000_299_001); + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1_000_299_002); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageUsageFlags { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b10_0000_0000_0000); + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b100_0000_0000_0000); + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl PipelineStageFlags2 { + pub const VIDEO_ENCODE_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl QueryType { + pub const VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR: Self = Self(1_000_299_000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl QueueFlags { + pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl StructureType { + pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000); + pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001); + pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1_000_299_002); + pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003); + pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1_000_299_004); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl VideoCodingControlFlagsKHR { + pub const ENCODE_RATE_CONTROL: Self = Self(0b10); + pub const ENCODE_RATE_CONTROL_LAYER: Self = Self(0b100); +} +impl NvDeviceDiagnosticsConfigFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_diagnostics_config\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvDeviceDiagnosticsConfigFn {} +unsafe impl Send for NvDeviceDiagnosticsConfigFn {} +unsafe impl Sync for NvDeviceDiagnosticsConfigFn {} +impl NvDeviceDiagnosticsConfigFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_device_diagnostics_config'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1_000_300_000); + pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: Self = Self(1_000_300_001); +} +impl QcomRenderPassStoreOpsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_store_ops\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct QcomRenderPassStoreOpsFn {} +unsafe impl Send for QcomRenderPassStoreOpsFn {} +unsafe impl Sync for QcomRenderPassStoreOpsFn {} +impl QcomRenderPassStoreOpsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_render_pass_store_ops'"] +impl AttachmentStoreOp { + pub const NONE_QCOM: Self = Self::NONE; +} +impl QcomExtension303Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_303\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension303Fn {} +unsafe impl Send for QcomExtension303Fn {} +unsafe impl Sync for QcomExtension303Fn {} +impl QcomExtension303Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension304Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_304\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension304Fn {} +unsafe impl Send for QcomExtension304Fn {} +unsafe impl Sync for QcomExtension304Fn {} +impl QcomExtension304Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension305Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_305\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension305Fn {} +unsafe impl Send for QcomExtension305Fn {} +unsafe impl Sync for QcomExtension305Fn {} +impl QcomExtension305Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension306Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_306\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension306Fn {} +unsafe impl Send for QcomExtension306Fn {} +unsafe impl Sync for QcomExtension306Fn {} +impl QcomExtension306Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension307Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_307\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension307Fn {} +unsafe impl Send for QcomExtension307Fn {} +unsafe impl Sync for QcomExtension307Fn {} +impl QcomExtension307Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension308Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_308\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension308Fn {} +unsafe impl Send for NvExtension308Fn {} +unsafe impl Sync for NvExtension308Fn {} +impl NvExtension308Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension309Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_309\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension309Fn {} +unsafe impl Send for KhrExtension309Fn {} +unsafe impl Sync for KhrExtension309Fn {} +impl KhrExtension309Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension310Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_310\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension310Fn {} +unsafe impl Send for QcomExtension310Fn {} +unsafe impl Sync for QcomExtension310Fn {} +impl QcomExtension310Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_310'"] +impl StructureType { + pub const RESERVED_QCOM: Self = Self(1_000_309_000); +} +impl NvExtension311Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_311\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension311Fn {} +unsafe impl Send for NvExtension311Fn {} +unsafe impl Sync for NvExtension311Fn {} +impl NvExtension311Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMetalObjectsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_objects\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkExportMetalObjectsEXT = + unsafe extern "system" fn(device: Device, p_metal_objects_info: *mut ExportMetalObjectsInfoEXT); +#[derive(Clone)] +pub struct ExtMetalObjectsFn { + pub export_metal_objects_ext: PFN_vkExportMetalObjectsEXT, +} +unsafe impl Send for ExtMetalObjectsFn {} +unsafe impl Sync for ExtMetalObjectsFn {} +impl ExtMetalObjectsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + export_metal_objects_ext: unsafe { + unsafe extern "system" fn export_metal_objects_ext( + _device: Device, + _p_metal_objects_info: *mut ExportMetalObjectsInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(export_metal_objects_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0"); + let val = _f(cname); + if val.is_null() { + export_metal_objects_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_metal_objects'"] +impl StructureType { + pub const EXPORT_METAL_OBJECT_CREATE_INFO_EXT: Self = Self(1_000_311_000); + pub const EXPORT_METAL_OBJECTS_INFO_EXT: Self = Self(1_000_311_001); + pub const EXPORT_METAL_DEVICE_INFO_EXT: Self = Self(1_000_311_002); + pub const EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: Self = Self(1_000_311_003); + pub const EXPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_004); + pub const IMPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_005); + pub const EXPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_006); + pub const IMPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_007); + pub const EXPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_008); + pub const IMPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_009); + pub const EXPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_010); + pub const IMPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_011); +} +impl ExtExtension313Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_313\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension313Fn {} +unsafe impl Send for ExtExtension313Fn {} +unsafe impl Sync for ExtExtension313Fn {} +impl ExtExtension313Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension314Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_314\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension314Fn {} +unsafe impl Send for AmdExtension314Fn {} +unsafe impl Sync for AmdExtension314Fn {} +impl AmdExtension314Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSynchronization2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_synchronization2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetEvent2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + p_dependency_info: *const DependencyInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResetEvent2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWaitEvents2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event_count: u32, + p_events: *const Event, + p_dependency_infos: *const DependencyInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPipelineBarrier2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_dependency_info: *const DependencyInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteTimestamp2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + stage: PipelineStageFlags2, + query_pool: QueryPool, + query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSubmit2 = unsafe extern "system" fn( + queue: Queue, + submit_count: u32, + p_submits: *const SubmitInfo2, + fence: Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn( + command_buffer: CommandBuffer, + stage: PipelineStageFlags2, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn( + queue: Queue, + p_checkpoint_data_count: *mut u32, + p_checkpoint_data: *mut CheckpointData2NV, +); +#[derive(Clone)] +pub struct KhrSynchronization2Fn { + pub cmd_set_event2_khr: PFN_vkCmdSetEvent2, + pub cmd_reset_event2_khr: PFN_vkCmdResetEvent2, + pub cmd_wait_events2_khr: PFN_vkCmdWaitEvents2, + pub cmd_pipeline_barrier2_khr: PFN_vkCmdPipelineBarrier2, + pub cmd_write_timestamp2_khr: PFN_vkCmdWriteTimestamp2, + pub queue_submit2_khr: PFN_vkQueueSubmit2, + pub cmd_write_buffer_marker2_amd: PFN_vkCmdWriteBufferMarker2AMD, + pub get_queue_checkpoint_data2_nv: PFN_vkGetQueueCheckpointData2NV, +} +unsafe impl Send for KhrSynchronization2Fn {} +unsafe impl Sync for KhrSynchronization2Fn {} +impl KhrSynchronization2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_event2_khr: unsafe { + unsafe extern "system" fn cmd_set_event2_khr( + _command_buffer: CommandBuffer, + _event: Event, + _p_dependency_info: *const DependencyInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_event2_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_event2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_reset_event2_khr: unsafe { + unsafe extern "system" fn cmd_reset_event2_khr( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_reset_event2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_reset_event2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_wait_events2_khr: unsafe { + unsafe extern "system" fn cmd_wait_events2_khr( + _command_buffer: CommandBuffer, + _event_count: u32, + _p_events: *const Event, + _p_dependency_infos: *const DependencyInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_wait_events2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_wait_events2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_pipeline_barrier2_khr: unsafe { + unsafe extern "system" fn cmd_pipeline_barrier2_khr( + _command_buffer: CommandBuffer, + _p_dependency_info: *const DependencyInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_pipeline_barrier2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_pipeline_barrier2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_timestamp2_khr: unsafe { + unsafe extern "system" fn cmd_write_timestamp2_khr( + _command_buffer: CommandBuffer, + _stage: PipelineStageFlags2, + _query_pool: QueryPool, + _query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_timestamp2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_write_timestamp2_khr + } else { + ::std::mem::transmute(val) + } + }, + queue_submit2_khr: unsafe { + unsafe extern "system" fn queue_submit2_khr( + _queue: Queue, + _submit_count: u32, + _p_submits: *const SubmitInfo2, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_submit2_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2KHR\0"); + let val = _f(cname); + if val.is_null() { + queue_submit2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_buffer_marker2_amd: unsafe { + unsafe extern "system" fn cmd_write_buffer_marker2_amd( + _command_buffer: CommandBuffer, + _stage: PipelineStageFlags2, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _marker: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_buffer_marker2_amd) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteBufferMarker2AMD\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_buffer_marker2_amd + } else { + ::std::mem::transmute(val) + } + }, + get_queue_checkpoint_data2_nv: unsafe { + unsafe extern "system" fn get_queue_checkpoint_data2_nv( + _queue: Queue, + _p_checkpoint_data_count: *mut u32, + _p_checkpoint_data: *mut CheckpointData2NV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_queue_checkpoint_data2_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetQueueCheckpointData2NV\0", + ); + let val = _f(cname); + if val.is_null() { + get_queue_checkpoint_data2_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl AccessFlags { + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl AccessFlags2 { + pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000); + #[doc = "read access flag for reading conditional rendering predicate"] + pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000); + pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000); + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self = + Self(0b1000_0000_0000_0000_0000_0000); + pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR; + pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR; + pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR; + pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl EventCreateFlags { + pub const DEVICE_ONLY_KHR: Self = Self::DEVICE_ONLY; +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl ImageLayout { + pub const READ_ONLY_OPTIMAL_KHR: Self = Self::READ_ONLY_OPTIMAL; + pub const ATTACHMENT_OPTIMAL_KHR: Self = Self::ATTACHMENT_OPTIMAL; +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl PipelineStageFlags { + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl PipelineStageFlags2 { + pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + #[doc = "A pipeline stage for conditional rendering predicate fetch"] + pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000); + pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000); + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; + pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR; + pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR; + pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const TASK_SHADER_NV: Self = Self::TASK_SHADER_EXT; + pub const MESH_SHADER_NV: Self = Self::MESH_SHADER_EXT; + pub const TASK_SHADER_EXT: Self = Self(0b1000_0000_0000_0000_0000); + pub const MESH_SHADER_EXT: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl StructureType { + pub const MEMORY_BARRIER_2_KHR: Self = Self::MEMORY_BARRIER_2; + pub const BUFFER_MEMORY_BARRIER_2_KHR: Self = Self::BUFFER_MEMORY_BARRIER_2; + pub const IMAGE_MEMORY_BARRIER_2_KHR: Self = Self::IMAGE_MEMORY_BARRIER_2; + pub const DEPENDENCY_INFO_KHR: Self = Self::DEPENDENCY_INFO; + pub const SUBMIT_INFO_2_KHR: Self = Self::SUBMIT_INFO_2; + pub const SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::SEMAPHORE_SUBMIT_INFO; + pub const COMMAND_BUFFER_SUBMIT_INFO_KHR: Self = Self::COMMAND_BUFFER_SUBMIT_INFO; + pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: Self = Self(1_000_314_008); + pub const CHECKPOINT_DATA_2_NV: Self = Self(1_000_314_009); +} +impl AmdExtension316Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_316\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension316Fn {} +unsafe impl Send for AmdExtension316Fn {} +unsafe impl Sync for AmdExtension316Fn {} +impl AmdExtension316Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtDescriptorBufferFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_buffer\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn( + device: Device, + layout: DescriptorSetLayout, + p_layout_size_in_bytes: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn( + device: Device, + layout: DescriptorSetLayout, + binding: u32, + p_offset: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorEXT = unsafe extern "system" fn( + device: Device, + p_descriptor_info: *const DescriptorGetInfoEXT, + data_size: usize, + p_descriptor: *mut c_void, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer_count: u32, + p_binding_infos: *const DescriptorBufferBindingInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: u32, + set_count: u32, + p_buffer_indices: *const u32, + p_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const BufferCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const ImageCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const ImageViewCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const SamplerCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = + unsafe extern "system" fn( + device: Device, + p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, + ) -> Result; +#[derive(Clone)] +pub struct ExtDescriptorBufferFn { + pub get_descriptor_set_layout_size_ext: PFN_vkGetDescriptorSetLayoutSizeEXT, + pub get_descriptor_set_layout_binding_offset_ext: PFN_vkGetDescriptorSetLayoutBindingOffsetEXT, + pub get_descriptor_ext: PFN_vkGetDescriptorEXT, + pub cmd_bind_descriptor_buffers_ext: PFN_vkCmdBindDescriptorBuffersEXT, + pub cmd_set_descriptor_buffer_offsets_ext: PFN_vkCmdSetDescriptorBufferOffsetsEXT, + pub cmd_bind_descriptor_buffer_embedded_samplers_ext: + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, + pub get_buffer_opaque_capture_descriptor_data_ext: + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT, + pub get_image_opaque_capture_descriptor_data_ext: PFN_vkGetImageOpaqueCaptureDescriptorDataEXT, + pub get_image_view_opaque_capture_descriptor_data_ext: + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT, + pub get_sampler_opaque_capture_descriptor_data_ext: + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT, + pub get_acceleration_structure_opaque_capture_descriptor_data_ext: + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, +} +unsafe impl Send for ExtDescriptorBufferFn {} +unsafe impl Sync for ExtDescriptorBufferFn {} +impl ExtDescriptorBufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_descriptor_set_layout_size_ext: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_size_ext( + _device: Device, + _layout: DescriptorSetLayout, + _p_layout_size_in_bytes: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_size_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutSizeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_size_ext + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_layout_binding_offset_ext: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext( + _device: Device, + _layout: DescriptorSetLayout, + _binding: u32, + _p_offset: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_binding_offset_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutBindingOffsetEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_binding_offset_ext + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_ext: unsafe { + unsafe extern "system" fn get_descriptor_ext( + _device: Device, + _p_descriptor_info: *const DescriptorGetInfoEXT, + _data_size: usize, + _p_descriptor: *mut c_void, + ) { + panic!(concat!("Unable to load ", stringify!(get_descriptor_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0"); + let val = _f(cname); + if val.is_null() { + get_descriptor_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_buffers_ext: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_buffers_ext( + _command_buffer: CommandBuffer, + _buffer_count: u32, + _p_binding_infos: *const DescriptorBufferBindingInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_buffers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindDescriptorBuffersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_buffers_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_descriptor_buffer_offsets_ext: unsafe { + unsafe extern "system" fn cmd_set_descriptor_buffer_offsets_ext( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _first_set: u32, + _set_count: u32, + _p_buffer_indices: *const u32, + _p_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_descriptor_buffer_offsets_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDescriptorBufferOffsetsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_descriptor_buffer_offsets_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_buffer_embedded_samplers_ext: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _set: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_buffer_embedded_samplers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_buffer_embedded_samplers_ext + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const BufferCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const ImageCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_view_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_image_view_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const ImageViewCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageViewOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_view_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_sampler_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const SamplerCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_sampler_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSamplerOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_sampler_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl AccelerationStructureCreateFlagsKHR { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl AccessFlags2 { + pub const DESCRIPTOR_BUFFER_READ_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl BufferCreateFlags { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl BufferUsageFlags { + pub const SAMPLER_DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const RESOURCE_DESCRIPTOR_BUFFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl DescriptorSetLayoutCreateFlags { + pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b1_0000); + pub const EMBEDDED_IMMUTABLE_SAMPLERS_EXT: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl ImageCreateFlags { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl ImageViewCreateFlags { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl PipelineCreateFlags { + pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl SamplerCreateFlags { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: Self = Self(1_000_316_000); + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: Self = + Self(1_000_316_001); + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: Self = Self(1_000_316_002); + pub const DESCRIPTOR_ADDRESS_INFO_EXT: Self = Self(1_000_316_003); + pub const DESCRIPTOR_GET_INFO_EXT: Self = Self(1_000_316_004); + pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_005); + pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_006); + pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_007); + pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_008); + pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: Self = Self(1_000_316_010); + pub const DESCRIPTOR_BUFFER_BINDING_INFO_EXT: Self = Self(1_000_316_011); + pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: Self = + Self(1_000_316_012); + pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_009); +} +impl AmdExtension318Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_318\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension318Fn {} +unsafe impl Send for AmdExtension318Fn {} +unsafe impl Sync for AmdExtension318Fn {} +impl AmdExtension318Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension319Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_319\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension319Fn {} +unsafe impl Send for AmdExtension319Fn {} +unsafe impl Sync for AmdExtension319Fn {} +impl AmdExtension319Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_extension_319'"] +impl DescriptorSetLayoutCreateFlags { + pub const RESERVED_3_AMD: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_AMD_extension_319'"] +impl PipelineLayoutCreateFlags { + pub const RESERVED_0_AMD: Self = Self(0b1); +} +impl AmdExtension320Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_320\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension320Fn {} +unsafe impl Send for AmdExtension320Fn {} +unsafe impl Sync for AmdExtension320Fn {} +impl AmdExtension320Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtGraphicsPipelineLibraryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_graphics_pipeline_library\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtGraphicsPipelineLibraryFn {} +unsafe impl Send for ExtGraphicsPipelineLibraryFn {} +unsafe impl Sync for ExtGraphicsPipelineLibraryFn {} +impl ExtGraphicsPipelineLibraryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"] +impl PipelineCreateFlags { + pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const LINK_TIME_OPTIMIZATION_EXT: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"] +impl PipelineLayoutCreateFlags { + pub const INDEPENDENT_SETS_EXT: Self = Self(0b10); +} +#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: Self = Self(1_000_320_000); + pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: Self = Self(1_000_320_001); + pub const GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: Self = Self(1_000_320_002); +} +impl AmdShaderEarlyAndLateFragmentTestsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_AMD_shader_early_and_late_fragment_tests\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderEarlyAndLateFragmentTestsFn {} +unsafe impl Send for AmdShaderEarlyAndLateFragmentTestsFn {} +unsafe impl Sync for AmdShaderEarlyAndLateFragmentTestsFn {} +impl AmdShaderEarlyAndLateFragmentTestsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_shader_early_and_late_fragment_tests'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: Self = + Self(1_000_321_000); +} +impl KhrFragmentShaderBarycentricFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shader_barycentric\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrFragmentShaderBarycentricFn {} +unsafe impl Send for KhrFragmentShaderBarycentricFn {} +unsafe impl Sync for KhrFragmentShaderBarycentricFn {} +impl KhrFragmentShaderBarycentricFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_fragment_shader_barycentric'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: Self = Self(1_000_203_000); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: Self = + Self(1_000_322_000); +} +impl KhrShaderSubgroupUniformControlFlowFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_shader_subgroup_uniform_control_flow\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderSubgroupUniformControlFlowFn {} +unsafe impl Send for KhrShaderSubgroupUniformControlFlowFn {} +unsafe impl Sync for KhrShaderSubgroupUniformControlFlowFn {} +impl KhrShaderSubgroupUniformControlFlowFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_subgroup_uniform_control_flow'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: Self = + Self(1_000_323_000); +} +impl KhrExtension325Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_325\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension325Fn {} +unsafe impl Send for KhrExtension325Fn {} +unsafe impl Sync for KhrExtension325Fn {} +impl KhrExtension325Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrZeroInitializeWorkgroupMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_zero_initialize_workgroup_memory\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrZeroInitializeWorkgroupMemoryFn {} +unsafe impl Send for KhrZeroInitializeWorkgroupMemoryFn {} +unsafe impl Sync for KhrZeroInitializeWorkgroupMemoryFn {} +impl KhrZeroInitializeWorkgroupMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_zero_initialize_workgroup_memory'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; +} +impl NvFragmentShadingRateEnumsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shading_rate_enums\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + shading_rate: FragmentShadingRateNV, + combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2], +); +#[derive(Clone)] +pub struct NvFragmentShadingRateEnumsFn { + pub cmd_set_fragment_shading_rate_enum_nv: PFN_vkCmdSetFragmentShadingRateEnumNV, +} +unsafe impl Send for NvFragmentShadingRateEnumsFn {} +unsafe impl Sync for NvFragmentShadingRateEnumsFn {} +impl NvFragmentShadingRateEnumsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_fragment_shading_rate_enum_nv: unsafe { + unsafe extern "system" fn cmd_set_fragment_shading_rate_enum_nv( + _command_buffer: CommandBuffer, + _shading_rate: FragmentShadingRateNV, + _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2], + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_fragment_shading_rate_enum_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetFragmentShadingRateEnumNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_fragment_shading_rate_enum_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_fragment_shading_rate_enums'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: Self = Self(1_000_326_000); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: Self = Self(1_000_326_001); + pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: Self = Self(1_000_326_002); +} +impl NvRayTracingMotionBlurFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing_motion_blur\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvRayTracingMotionBlurFn {} +unsafe impl Send for NvRayTracingMotionBlurFn {} +unsafe impl Sync for NvRayTracingMotionBlurFn {} +impl NvRayTracingMotionBlurFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"] +impl AccelerationStructureCreateFlagsKHR { + pub const MOTION_NV: Self = Self(0b100); +} +#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"] +impl BuildAccelerationStructureFlagsKHR { + pub const MOTION_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_ALLOW_MOTION_NV: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"] +impl StructureType { + pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: Self = Self(1_000_327_000); + pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: Self = Self(1_000_327_001); + pub const ACCELERATION_STRUCTURE_MOTION_INFO_NV: Self = Self(1_000_327_002); +} +impl ExtMeshShaderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mesh_shader\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectCountEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +); +#[derive(Clone)] +pub struct ExtMeshShaderFn { + pub cmd_draw_mesh_tasks_ext: PFN_vkCmdDrawMeshTasksEXT, + pub cmd_draw_mesh_tasks_indirect_ext: PFN_vkCmdDrawMeshTasksIndirectEXT, + pub cmd_draw_mesh_tasks_indirect_count_ext: PFN_vkCmdDrawMeshTasksIndirectCountEXT, +} +unsafe impl Send for ExtMeshShaderFn {} +unsafe impl Sync for ExtMeshShaderFn {} +impl ExtMeshShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_mesh_tasks_ext: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_ext( + _command_buffer: CommandBuffer, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_ext: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_ext( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawMeshTasksIndirectEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_count_ext: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_ext( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawMeshTasksIndirectCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_count_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl IndirectCommandsTokenTypeNV { + pub const DRAW_MESH_TASKS: Self = Self(1_000_328_000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl PipelineStageFlags { + pub const TASK_SHADER_EXT: Self = Self(0b1000_0000_0000_0000_0000); + pub const MESH_SHADER_EXT: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl QueryPipelineStatisticFlags { + pub const TASK_SHADER_INVOCATIONS_EXT: Self = Self(0b1000_0000_0000); + pub const MESH_SHADER_INVOCATIONS_EXT: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl QueryType { + pub const MESH_PRIMITIVES_GENERATED_EXT: Self = Self(1_000_328_000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl ShaderStageFlags { + pub const TASK_EXT: Self = Self(0b100_0000); + pub const MESH_EXT: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: Self = Self(1_000_328_000); + pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: Self = Self(1_000_328_001); +} +impl NvExtension330Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_330\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension330Fn {} +unsafe impl Send for NvExtension330Fn {} +unsafe impl Sync for NvExtension330Fn {} +impl NvExtension330Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtYcbcr2plane444FormatsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_2plane_444_formats\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtYcbcr2plane444FormatsFn {} +unsafe impl Send for ExtYcbcr2plane444FormatsFn {} +unsafe impl Sync for ExtYcbcr2plane444FormatsFn {} +impl ExtYcbcr2plane444FormatsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"] +impl Format { + pub const G8_B8R8_2PLANE_444_UNORM_EXT: Self = Self::G8_B8R8_2PLANE_444_UNORM; + pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: Self = + Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16; + pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: Self = + Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16; + pub const G16_B16R16_2PLANE_444_UNORM_EXT: Self = Self::G16_B16R16_2PLANE_444_UNORM; +} +#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"] +impl StructureType { + pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: Self = Self(1_000_330_000); +} +impl NvExtension332Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_332\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension332Fn {} +unsafe impl Send for NvExtension332Fn {} +unsafe impl Sync for NvExtension332Fn {} +impl NvExtension332Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtFragmentDensityMap2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtFragmentDensityMap2Fn {} +unsafe impl Send for ExtFragmentDensityMap2Fn {} +unsafe impl Sync for ExtFragmentDensityMap2Fn {} +impl ExtFragmentDensityMap2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_fragment_density_map2'"] +impl ImageViewCreateFlags { + pub const FRAGMENT_DENSITY_MAP_DEFERRED_EXT: Self = Self(0b10); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self(1_000_332_000); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: Self = Self(1_000_332_001); +} +impl QcomRotatedCopyCommandsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_rotated_copy_commands\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomRotatedCopyCommandsFn {} +unsafe impl Send for QcomRotatedCopyCommandsFn {} +unsafe impl Sync for QcomRotatedCopyCommandsFn {} +impl QcomRotatedCopyCommandsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_rotated_copy_commands'"] +impl StructureType { + pub const COPY_COMMAND_TRANSFORM_INFO_QCOM: Self = Self(1_000_333_000); +} +impl KhrExtension335Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_335\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension335Fn {} +unsafe impl Send for KhrExtension335Fn {} +unsafe impl Sync for KhrExtension335Fn {} +impl KhrExtension335Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtImageRobustnessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_robustness\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtImageRobustnessFn {} +unsafe impl Send for ExtImageRobustnessFn {} +unsafe impl Sync for ExtImageRobustnessFn {} +impl ExtImageRobustnessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_image_robustness'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; +} +impl KhrWorkgroupMemoryExplicitLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_workgroup_memory_explicit_layout\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrWorkgroupMemoryExplicitLayoutFn {} +unsafe impl Send for KhrWorkgroupMemoryExplicitLayoutFn {} +unsafe impl Sync for KhrWorkgroupMemoryExplicitLayoutFn {} +impl KhrWorkgroupMemoryExplicitLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_workgroup_memory_explicit_layout'"] +impl StructureType { + pub const PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: Self = + Self(1_000_336_000); +} +impl KhrCopyCommands2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_copy_commands2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBuffer2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_copy_buffer_info: *const CopyBufferInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImage2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_copy_image_info: *const CopyImageInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBlitImage2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_blit_image_info: *const BlitImageInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResolveImage2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_resolve_image_info: *const ResolveImageInfo2, +); +#[derive(Clone)] +pub struct KhrCopyCommands2Fn { + pub cmd_copy_buffer2_khr: PFN_vkCmdCopyBuffer2, + pub cmd_copy_image2_khr: PFN_vkCmdCopyImage2, + pub cmd_copy_buffer_to_image2_khr: PFN_vkCmdCopyBufferToImage2, + pub cmd_copy_image_to_buffer2_khr: PFN_vkCmdCopyImageToBuffer2, + pub cmd_blit_image2_khr: PFN_vkCmdBlitImage2, + pub cmd_resolve_image2_khr: PFN_vkCmdResolveImage2, +} +unsafe impl Send for KhrCopyCommands2Fn {} +unsafe impl Sync for KhrCopyCommands2Fn {} +impl KhrCopyCommands2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_copy_buffer2_khr: unsafe { + unsafe extern "system" fn cmd_copy_buffer2_khr( + _command_buffer: CommandBuffer, + _p_copy_buffer_info: *const CopyBufferInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image2_khr: unsafe { + unsafe extern "system" fn cmd_copy_image2_khr( + _command_buffer: CommandBuffer, + _p_copy_image_info: *const CopyImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_image2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer_to_image2_khr: unsafe { + unsafe extern "system" fn cmd_copy_buffer_to_image2_khr( + _command_buffer: CommandBuffer, + _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_buffer_to_image2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyBufferToImage2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer_to_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image_to_buffer2_khr: unsafe { + unsafe extern "system" fn cmd_copy_image_to_buffer2_khr( + _command_buffer: CommandBuffer, + _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_image_to_buffer2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyImageToBuffer2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_image_to_buffer2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_blit_image2_khr: unsafe { + unsafe extern "system" fn cmd_blit_image2_khr( + _command_buffer: CommandBuffer, + _p_blit_image_info: *const BlitImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_blit_image2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_blit_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_resolve_image2_khr: unsafe { + unsafe extern "system" fn cmd_resolve_image2_khr( + _command_buffer: CommandBuffer, + _p_resolve_image_info: *const ResolveImageInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_resolve_image2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_resolve_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_copy_commands2'"] +impl StructureType { + pub const COPY_BUFFER_INFO_2_KHR: Self = Self::COPY_BUFFER_INFO_2; + pub const COPY_IMAGE_INFO_2_KHR: Self = Self::COPY_IMAGE_INFO_2; + pub const COPY_BUFFER_TO_IMAGE_INFO_2_KHR: Self = Self::COPY_BUFFER_TO_IMAGE_INFO_2; + pub const COPY_IMAGE_TO_BUFFER_INFO_2_KHR: Self = Self::COPY_IMAGE_TO_BUFFER_INFO_2; + pub const BLIT_IMAGE_INFO_2_KHR: Self = Self::BLIT_IMAGE_INFO_2; + pub const RESOLVE_IMAGE_INFO_2_KHR: Self = Self::RESOLVE_IMAGE_INFO_2; + pub const BUFFER_COPY_2_KHR: Self = Self::BUFFER_COPY_2; + pub const IMAGE_COPY_2_KHR: Self = Self::IMAGE_COPY_2; + pub const IMAGE_BLIT_2_KHR: Self = Self::IMAGE_BLIT_2; + pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self::BUFFER_IMAGE_COPY_2; + pub const IMAGE_RESOLVE_2_KHR: Self = Self::IMAGE_RESOLVE_2; +} +impl ExtImageCompressionControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_compression_control\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn( + device: Device, + image: Image, + p_subresource: *const ImageSubresource2EXT, + p_layout: *mut SubresourceLayout2EXT, +); +#[derive(Clone)] +pub struct ExtImageCompressionControlFn { + pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2EXT, +} +unsafe impl Send for ExtImageCompressionControlFn {} +unsafe impl Sync for ExtImageCompressionControlFn {} +impl ExtImageCompressionControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_image_subresource_layout2_ext: unsafe { + unsafe extern "system" fn get_image_subresource_layout2_ext( + _device: Device, + _image: Image, + _p_subresource: *const ImageSubresource2EXT, + _p_layout: *mut SubresourceLayout2EXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_subresource_layout2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSubresourceLayout2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_subresource_layout2_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_image_compression_control'"] +impl Result { + pub const ERROR_COMPRESSION_EXHAUSTED_EXT: Self = Self(-1_000_338_000); +} +#[doc = "Generated from 'VK_EXT_image_compression_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self(1_000_338_000); + pub const IMAGE_COMPRESSION_CONTROL_EXT: Self = Self(1_000_338_001); + pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self(1_000_338_002); + pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self(1_000_338_003); + pub const IMAGE_COMPRESSION_PROPERTIES_EXT: Self = Self(1_000_338_004); +} +impl ExtAttachmentFeedbackLoopLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_attachment_feedback_loop_layout\0", + ) + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtAttachmentFeedbackLoopLayoutFn {} +unsafe impl Send for ExtAttachmentFeedbackLoopLayoutFn {} +unsafe impl Sync for ExtAttachmentFeedbackLoopLayoutFn {} +impl ExtAttachmentFeedbackLoopLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl DependencyFlags { + #[doc = "Dependency may be a feedback loop"] + pub const FEEDBACK_LOOP_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl ImageLayout { + pub const ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: Self = Self(1_000_339_000); +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl ImageUsageFlags { + pub const ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl PipelineCreateFlags { + pub const COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: Self = + Self(1_000_339_000); +} +impl Ext4444FormatsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_4444_formats\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct Ext4444FormatsFn {} +unsafe impl Send for Ext4444FormatsFn {} +unsafe impl Sync for Ext4444FormatsFn {} +impl Ext4444FormatsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_4444_formats'"] +impl Format { + pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self::A4R4G4B4_UNORM_PACK16; + pub const A4B4G4R4_UNORM_PACK16_EXT: Self = Self::A4B4G4R4_UNORM_PACK16; +} +#[doc = "Generated from 'VK_EXT_4444_formats'"] +impl StructureType { + pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1_000_340_000); +} +impl ExtDeviceFaultFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_fault\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn( + device: Device, + p_fault_counts: *mut DeviceFaultCountsEXT, + p_fault_info: *mut DeviceFaultInfoEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtDeviceFaultFn { + pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT, +} +unsafe impl Send for ExtDeviceFaultFn {} +unsafe impl Sync for ExtDeviceFaultFn {} +impl ExtDeviceFaultFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_device_fault_info_ext: unsafe { + unsafe extern "system" fn get_device_fault_info_ext( + _device: Device, + _p_fault_counts: *mut DeviceFaultCountsEXT, + _p_fault_info: *mut DeviceFaultInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_fault_info_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceFaultInfoEXT\0"); + let val = _f(cname); + if val.is_null() { + get_device_fault_info_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_device_fault'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FAULT_FEATURES_EXT: Self = Self(1_000_341_000); + pub const DEVICE_FAULT_COUNTS_EXT: Self = Self(1_000_341_001); + pub const DEVICE_FAULT_INFO_EXT: Self = Self(1_000_341_002); +} +impl ArmRasterizationOrderAttachmentAccessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_ARM_rasterization_order_attachment_access\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ArmRasterizationOrderAttachmentAccessFn {} +unsafe impl Send for ArmRasterizationOrderAttachmentAccessFn {} +unsafe impl Sync for ArmRasterizationOrderAttachmentAccessFn {} +impl ArmRasterizationOrderAttachmentAccessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl PipelineColorBlendStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT; +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl PipelineDepthStencilStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT; + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT; +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: Self = + Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl SubpassDescriptionFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT; + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT; + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT; +} +impl ArmExtension344Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_344\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension344Fn {} +unsafe impl Send for ArmExtension344Fn {} +unsafe impl Sync for ArmExtension344Fn {} +impl ArmExtension344Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtRgba10x6FormatsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_rgba10x6_formats\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtRgba10x6FormatsFn {} +unsafe impl Send for ExtRgba10x6FormatsFn {} +unsafe impl Sync for ExtRgba10x6FormatsFn {} +impl ExtRgba10x6FormatsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_rgba10x6_formats'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: Self = Self(1_000_344_000); +} +impl NvAcquireWinrtDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_acquire_winrt_display\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireWinrtDisplayNV = + unsafe extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetWinrtDisplayNV = unsafe extern "system" fn( + physical_device: PhysicalDevice, + device_relative_id: u32, + p_display: *mut DisplayKHR, +) -> Result; +#[derive(Clone)] +pub struct NvAcquireWinrtDisplayFn { + pub acquire_winrt_display_nv: PFN_vkAcquireWinrtDisplayNV, + pub get_winrt_display_nv: PFN_vkGetWinrtDisplayNV, +} +unsafe impl Send for NvAcquireWinrtDisplayFn {} +unsafe impl Sync for NvAcquireWinrtDisplayFn {} +impl NvAcquireWinrtDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + acquire_winrt_display_nv: unsafe { + unsafe extern "system" fn acquire_winrt_display_nv( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_winrt_display_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireWinrtDisplayNV\0"); + let val = _f(cname); + if val.is_null() { + acquire_winrt_display_nv + } else { + ::std::mem::transmute(val) + } + }, + get_winrt_display_nv: unsafe { + unsafe extern "system" fn get_winrt_display_nv( + _physical_device: PhysicalDevice, + _device_relative_id: u32, + _p_display: *mut DisplayKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_winrt_display_nv))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetWinrtDisplayNV\0"); + let val = _f(cname); + if val.is_null() { + get_winrt_display_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtDirectfbSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_directfb_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDirectFBSurfaceEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const DirectFBSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + dfb: *mut IDirectFB, + ) -> Bool32; +#[derive(Clone)] +pub struct ExtDirectfbSurfaceFn { + pub create_direct_fb_surface_ext: PFN_vkCreateDirectFBSurfaceEXT, + pub get_physical_device_direct_fb_presentation_support_ext: + PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT, +} +unsafe impl Send for ExtDirectfbSurfaceFn {} +unsafe impl Sync for ExtDirectfbSurfaceFn {} +impl ExtDirectfbSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_direct_fb_surface_ext: unsafe { + unsafe extern "system" fn create_direct_fb_surface_ext( + _instance: Instance, + _p_create_info: *const DirectFBSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_direct_fb_surface_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDirectFBSurfaceEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_direct_fb_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_direct_fb_presentation_support_ext: unsafe { + unsafe extern "system" fn get_physical_device_direct_fb_presentation_support_ext( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _dfb: *mut IDirectFB, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_direct_fb_presentation_support_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDirectFBPresentationSupportEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_direct_fb_presentation_support_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_directfb_surface'"] +impl StructureType { + pub const DIRECTFB_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_346_000); +} +impl KhrExtension350Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_350\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension350Fn {} +unsafe impl Send for KhrExtension350Fn {} +unsafe impl Sync for KhrExtension350Fn {} +impl KhrExtension350Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension351Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_351\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension351Fn {} +unsafe impl Send for NvExtension351Fn {} +unsafe impl Sync for NvExtension351Fn {} +impl NvExtension351Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ValveMutableDescriptorTypeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_VALVE_mutable_descriptor_type\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ValveMutableDescriptorTypeFn {} +unsafe impl Send for ValveMutableDescriptorTypeFn {} +unsafe impl Sync for ValveMutableDescriptorTypeFn {} +impl ValveMutableDescriptorTypeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorPoolCreateFlags { + pub const HOST_ONLY_VALVE: Self = Self::HOST_ONLY_EXT; +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorSetLayoutCreateFlags { + pub const HOST_ONLY_POOL_VALVE: Self = Self::HOST_ONLY_POOL_EXT; +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorType { + pub const MUTABLE_VALVE: Self = Self::MUTABLE_EXT; +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self = + Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self = + Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; +} +impl ExtVertexInputDynamicStateFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_input_dynamic_state\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetVertexInputEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + vertex_binding_description_count: u32, + p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT, + vertex_attribute_description_count: u32, + p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT, +); +#[derive(Clone)] +pub struct ExtVertexInputDynamicStateFn { + pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT, +} +unsafe impl Send for ExtVertexInputDynamicStateFn {} +unsafe impl Sync for ExtVertexInputDynamicStateFn {} +impl ExtVertexInputDynamicStateFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_vertex_input_ext: unsafe { + unsafe extern "system" fn cmd_set_vertex_input_ext( + _command_buffer: CommandBuffer, + _vertex_binding_description_count: u32, + _p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT, + _vertex_attribute_description_count: u32, + _p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_vertex_input_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_vertex_input_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"] +impl DynamicState { + pub const VERTEX_INPUT_EXT: Self = Self(1_000_352_000); +} +#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_352_000); + pub const VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: Self = Self(1_000_352_001); + pub const VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: Self = Self(1_000_352_002); +} +impl ExtPhysicalDeviceDrmFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_physical_device_drm\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPhysicalDeviceDrmFn {} +unsafe impl Send for ExtPhysicalDeviceDrmFn {} +unsafe impl Sync for ExtPhysicalDeviceDrmFn {} +impl ExtPhysicalDeviceDrmFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_physical_device_drm'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: Self = Self(1_000_353_000); +} +impl ExtDeviceAddressBindingReportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_device_address_binding_report\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDeviceAddressBindingReportFn {} +unsafe impl Send for ExtDeviceAddressBindingReportFn {} +unsafe impl Sync for ExtDeviceAddressBindingReportFn {} +impl ExtDeviceAddressBindingReportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_device_address_binding_report'"] +impl DebugUtilsMessageTypeFlagsEXT { + pub const DEVICE_ADDRESS_BINDING: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_device_address_binding_report'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: Self = Self(1_000_354_000); + pub const DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: Self = Self(1_000_354_001); +} +impl ExtDepthClipControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_control\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDepthClipControlFn {} +unsafe impl Send for ExtDepthClipControlFn {} +unsafe impl Sync for ExtDepthClipControlFn {} +impl ExtDepthClipControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_depth_clip_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: Self = Self(1_000_355_000); + pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: Self = Self(1_000_355_001); +} +impl ExtPrimitiveTopologyListRestartFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_primitive_topology_list_restart\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPrimitiveTopologyListRestartFn {} +unsafe impl Send for ExtPrimitiveTopologyListRestartFn {} +unsafe impl Sync for ExtPrimitiveTopologyListRestartFn {} +impl ExtPrimitiveTopologyListRestartFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_primitive_topology_list_restart'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: Self = + Self(1_000_356_000); +} +impl KhrExtension358Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_358\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension358Fn {} +unsafe impl Send for KhrExtension358Fn {} +unsafe impl Sync for KhrExtension358Fn {} +impl KhrExtension358Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension359Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_359\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension359Fn {} +unsafe impl Send for ExtExtension359Fn {} +unsafe impl Sync for ExtExtension359Fn {} +impl ExtExtension359Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension360Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_360\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension360Fn {} +unsafe impl Send for ExtExtension360Fn {} +unsafe impl Sync for ExtExtension360Fn {} +impl ExtExtension360Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrFormatFeatureFlags2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_format_feature_flags2\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct KhrFormatFeatureFlags2Fn {} +unsafe impl Send for KhrFormatFeatureFlags2Fn {} +unsafe impl Sync for KhrFormatFeatureFlags2Fn {} +impl KhrFormatFeatureFlags2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_format_feature_flags2'"] +impl StructureType { + pub const FORMAT_PROPERTIES_3_KHR: Self = Self::FORMAT_PROPERTIES_3; +} +impl ExtExtension362Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_362\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension362Fn {} +unsafe impl Send for ExtExtension362Fn {} +unsafe impl Sync for ExtExtension362Fn {} +impl ExtExtension362Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension363Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_363\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension363Fn {} +unsafe impl Send for ExtExtension363Fn {} +unsafe impl Sync for ExtExtension363Fn {} +impl ExtExtension363Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FuchsiaExtension364Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_364\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FuchsiaExtension364Fn {} +unsafe impl Send for FuchsiaExtension364Fn {} +unsafe impl Sync for FuchsiaExtension364Fn {} +impl FuchsiaExtension364Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FuchsiaExternalMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_memory\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryZirconHandleFUCHSIA = unsafe extern "system" fn( + device: Device, + p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA, + p_zircon_handle: *mut zx_handle_t, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA = unsafe extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + zircon_handle: zx_handle_t, + p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA, +) -> Result; +#[derive(Clone)] +pub struct FuchsiaExternalMemoryFn { + pub get_memory_zircon_handle_fuchsia: PFN_vkGetMemoryZirconHandleFUCHSIA, + pub get_memory_zircon_handle_properties_fuchsia: PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA, +} +unsafe impl Send for FuchsiaExternalMemoryFn {} +unsafe impl Sync for FuchsiaExternalMemoryFn {} +impl FuchsiaExternalMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_zircon_handle_fuchsia: unsafe { + unsafe extern "system" fn get_memory_zircon_handle_fuchsia( + _device: Device, + _p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA, + _p_zircon_handle: *mut zx_handle_t, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_zircon_handle_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryZirconHandleFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_zircon_handle_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + get_memory_zircon_handle_properties_fuchsia: unsafe { + unsafe extern "system" fn get_memory_zircon_handle_properties_fuchsia( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _zircon_handle: zx_handle_t, + _p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_zircon_handle_properties_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryZirconHandlePropertiesFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_zircon_handle_properties_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_FUCHSIA_external_memory'"] +impl ExternalMemoryHandleTypeFlags { + pub const ZIRCON_VMO_FUCHSIA: Self = Self(0b1000_0000_0000); +} +#[doc = "Generated from 'VK_FUCHSIA_external_memory'"] +impl StructureType { + pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_000); + pub const MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: Self = Self(1_000_364_001); + pub const MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_002); +} +impl FuchsiaExternalSemaphoreFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_semaphore\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn( + device: Device, + p_import_semaphore_zircon_handle_info: *const ImportSemaphoreZirconHandleInfoFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn( + device: Device, + p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA, + p_zircon_handle: *mut zx_handle_t, +) -> Result; +#[derive(Clone)] +pub struct FuchsiaExternalSemaphoreFn { + pub import_semaphore_zircon_handle_fuchsia: PFN_vkImportSemaphoreZirconHandleFUCHSIA, + pub get_semaphore_zircon_handle_fuchsia: PFN_vkGetSemaphoreZirconHandleFUCHSIA, +} +unsafe impl Send for FuchsiaExternalSemaphoreFn {} +unsafe impl Sync for FuchsiaExternalSemaphoreFn {} +impl FuchsiaExternalSemaphoreFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_semaphore_zircon_handle_fuchsia: unsafe { + unsafe extern "system" fn import_semaphore_zircon_handle_fuchsia( + _device: Device, + _p_import_semaphore_zircon_handle_info : * const ImportSemaphoreZirconHandleInfoFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_zircon_handle_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkImportSemaphoreZirconHandleFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + import_semaphore_zircon_handle_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + get_semaphore_zircon_handle_fuchsia: unsafe { + unsafe extern "system" fn get_semaphore_zircon_handle_fuchsia( + _device: Device, + _p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA, + _p_zircon_handle: *mut zx_handle_t, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_zircon_handle_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSemaphoreZirconHandleFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_semaphore_zircon_handle_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"] +impl ExternalSemaphoreHandleTypeFlags { + pub const ZIRCON_EVENT_FUCHSIA: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"] +impl StructureType { + pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_000); + pub const SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_001); +} +impl FuchsiaBufferCollectionFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_buffer_collection\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateBufferCollectionFUCHSIA = unsafe extern "system" fn( + device: Device, + p_create_info: *const BufferCollectionCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_collection: *mut BufferCollectionFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyBufferCollectionFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferCollectionPropertiesFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_properties: *mut BufferCollectionPropertiesFUCHSIA, +) -> Result; +#[derive(Clone)] +pub struct FuchsiaBufferCollectionFn { + pub create_buffer_collection_fuchsia: PFN_vkCreateBufferCollectionFUCHSIA, + pub set_buffer_collection_image_constraints_fuchsia: + PFN_vkSetBufferCollectionImageConstraintsFUCHSIA, + pub set_buffer_collection_buffer_constraints_fuchsia: + PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA, + pub destroy_buffer_collection_fuchsia: PFN_vkDestroyBufferCollectionFUCHSIA, + pub get_buffer_collection_properties_fuchsia: PFN_vkGetBufferCollectionPropertiesFUCHSIA, +} +unsafe impl Send for FuchsiaBufferCollectionFn {} +unsafe impl Sync for FuchsiaBufferCollectionFn {} +impl FuchsiaBufferCollectionFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_buffer_collection_fuchsia: unsafe { + unsafe extern "system" fn create_buffer_collection_fuchsia( + _device: Device, + _p_create_info: *const BufferCollectionCreateInfoFUCHSIA, + _p_allocator: *const AllocationCallbacks, + _p_collection: *mut BufferCollectionFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_buffer_collection_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateBufferCollectionFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + create_buffer_collection_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + set_buffer_collection_image_constraints_fuchsia: unsafe { + unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_buffer_collection_image_constraints_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetBufferCollectionImageConstraintsFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + set_buffer_collection_image_constraints_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + set_buffer_collection_buffer_constraints_fuchsia: unsafe { + unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_buffer_collection_buffer_constraints_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + set_buffer_collection_buffer_constraints_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + destroy_buffer_collection_fuchsia: unsafe { + unsafe extern "system" fn destroy_buffer_collection_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_buffer_collection_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyBufferCollectionFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_buffer_collection_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_collection_properties_fuchsia: unsafe { + unsafe extern "system" fn get_buffer_collection_properties_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_properties: *mut BufferCollectionPropertiesFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_collection_properties_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferCollectionPropertiesFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_collection_properties_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl DebugReportObjectTypeEXT { + pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl ObjectType { + #[doc = "VkBufferCollectionFUCHSIA"] + pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_000); + pub const IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_001); + pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_002); + pub const BUFFER_COLLECTION_PROPERTIES_FUCHSIA: Self = Self(1_000_366_003); + pub const BUFFER_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_004); + pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_005); + pub const IMAGE_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_006); + pub const IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_007); + pub const SYSMEM_COLOR_SPACE_FUCHSIA: Self = Self(1_000_366_008); + pub const BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_009); +} +impl FuchsiaExtension368Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_368\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FuchsiaExtension368Fn {} +unsafe impl Send for FuchsiaExtension368Fn {} +unsafe impl Sync for FuchsiaExtension368Fn {} +impl FuchsiaExtension368Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension369Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_369\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension369Fn {} +unsafe impl Send for QcomExtension369Fn {} +unsafe impl Sync for QcomExtension369Fn {} +impl QcomExtension369Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_369'"] +impl DescriptorBindingFlags { + pub const RESERVED_4_QCOM: Self = Self(0b1_0000); +} +impl HuaweiSubpassShadingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_subpass_shading\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn( + device: Device, + renderpass: RenderPass, + p_max_workgroup_size: *mut Extent2D, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSubpassShadingHUAWEI = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[derive(Clone)] +pub struct HuaweiSubpassShadingFn { + pub get_device_subpass_shading_max_workgroup_size_huawei: + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, + pub cmd_subpass_shading_huawei: PFN_vkCmdSubpassShadingHUAWEI, +} +unsafe impl Send for HuaweiSubpassShadingFn {} +unsafe impl Sync for HuaweiSubpassShadingFn {} +impl HuaweiSubpassShadingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_device_subpass_shading_max_workgroup_size_huawei: unsafe { + unsafe extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei( + _device: Device, + _renderpass: RenderPass, + _p_max_workgroup_size: *mut Extent2D, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_subpass_shading_max_workgroup_size_huawei) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_subpass_shading_max_workgroup_size_huawei + } else { + ::std::mem::transmute(val) + } + }, + cmd_subpass_shading_huawei: unsafe { + unsafe extern "system" fn cmd_subpass_shading_huawei( + _command_buffer: CommandBuffer, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_subpass_shading_huawei) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSubpassShadingHUAWEI\0"); + let val = _f(cname); + if val.is_null() { + cmd_subpass_shading_huawei + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] +impl PipelineBindPoint { + pub const SUBPASS_SHADING_HUAWEI: Self = Self(1_000_369_003); +} +#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] +impl PipelineStageFlags2 { + pub const SUBPASS_SHADING_HUAWEI: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] +impl ShaderStageFlags { + pub const SUBPASS_SHADING_HUAWEI: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] +impl StructureType { + pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: Self = Self(1_000_369_000); + pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: Self = Self(1_000_369_001); + pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: Self = Self(1_000_369_002); +} +impl HuaweiInvocationMaskFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_invocation_mask\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image_view: ImageView, + image_layout: ImageLayout, +); +#[derive(Clone)] +pub struct HuaweiInvocationMaskFn { + pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI, +} +unsafe impl Send for HuaweiInvocationMaskFn {} +unsafe impl Sync for HuaweiInvocationMaskFn {} +impl HuaweiInvocationMaskFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_bind_invocation_mask_huawei: unsafe { + unsafe extern "system" fn cmd_bind_invocation_mask_huawei( + _command_buffer: CommandBuffer, + _image_view: ImageView, + _image_layout: ImageLayout, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_invocation_mask_huawei) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindInvocationMaskHUAWEI\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_invocation_mask_huawei + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl AccessFlags2 { + pub const INVOCATION_MASK_READ_HUAWEI: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl ImageUsageFlags { + pub const INVOCATION_MASK_HUAWEI: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl PipelineStageFlags2 { + pub const INVOCATION_MASK_HUAWEI: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000); +} +impl NvExternalMemoryRdmaFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_rdma\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn( + device: Device, + p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV, + p_address: *mut RemoteAddressNV, +) -> Result; +#[derive(Clone)] +pub struct NvExternalMemoryRdmaFn { + pub get_memory_remote_address_nv: PFN_vkGetMemoryRemoteAddressNV, +} +unsafe impl Send for NvExternalMemoryRdmaFn {} +unsafe impl Sync for NvExternalMemoryRdmaFn {} +impl NvExternalMemoryRdmaFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_remote_address_nv: unsafe { + unsafe extern "system" fn get_memory_remote_address_nv( + _device: Device, + _p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV, + _p_address: *mut RemoteAddressNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_remote_address_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryRemoteAddressNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_remote_address_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_external_memory_rdma'"] +impl ExternalMemoryHandleTypeFlags { + pub const RDMA_ADDRESS_NV: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_external_memory_rdma'"] +impl MemoryPropertyFlags { + pub const RDMA_CAPABLE_NV: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_NV_external_memory_rdma'"] +impl StructureType { + pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1_000_371_000); + pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: Self = Self(1_000_371_001); +} +impl ExtPipelinePropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_properties\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn( + device: Device, + p_pipeline_info: *const PipelineInfoEXT, + p_pipeline_properties: *mut BaseOutStructure, +) -> Result; +#[derive(Clone)] +pub struct ExtPipelinePropertiesFn { + pub get_pipeline_properties_ext: PFN_vkGetPipelinePropertiesEXT, +} +unsafe impl Send for ExtPipelinePropertiesFn {} +unsafe impl Sync for ExtPipelinePropertiesFn {} +impl ExtPipelinePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_pipeline_properties_ext: unsafe { + unsafe extern "system" fn get_pipeline_properties_ext( + _device: Device, + _p_pipeline_info: *const PipelineInfoEXT, + _p_pipeline_properties: *mut BaseOutStructure, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelinePropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_pipeline_properties'"] +impl StructureType { + pub const PIPELINE_PROPERTIES_IDENTIFIER_EXT: Self = Self(1_000_372_000); + pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: Self = Self(1_000_372_001); + pub const PIPELINE_INFO_EXT: Self = Self::PIPELINE_INFO_KHR; +} +impl NvExtension374Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_374\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension374Fn {} +unsafe impl Send for NvExtension374Fn {} +unsafe impl Sync for NvExtension374Fn {} +impl NvExtension374Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_extension_374'"] +impl ExternalFenceHandleTypeFlags { + pub const RESERVED_4_NV: Self = Self(0b1_0000); + pub const RESERVED_5_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_NV_extension_374'"] +impl ExternalSemaphoreHandleTypeFlags { + pub const RESERVED_5_NV: Self = Self(0b10_0000); +} +impl NvExtension375Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_375\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension375Fn {} +unsafe impl Send for NvExtension375Fn {} +unsafe impl Sync for NvExtension375Fn {} +impl NvExtension375Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_extension_375'"] +impl ExternalMemoryHandleTypeFlags { + pub const RESERVED_13_NV: Self = Self(0b10_0000_0000_0000); +} +impl ExtExtension376Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_376\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension376Fn {} +unsafe impl Send for ExtExtension376Fn {} +unsafe impl Sync for ExtExtension376Fn {} +impl ExtExtension376Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMultisampledRenderToSingleSampledFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_multisampled_render_to_single_sampled\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtMultisampledRenderToSingleSampledFn {} +unsafe impl Send for ExtMultisampledRenderToSingleSampledFn {} +unsafe impl Sync for ExtMultisampledRenderToSingleSampledFn {} +impl ExtMultisampledRenderToSingleSampledFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"] +impl ImageCreateFlags { + pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: Self = + Self(1_000_376_000); + pub const SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: Self = Self(1_000_376_001); + pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: Self = Self(1_000_376_002); +} +impl ExtExtendedDynamicState2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPatchControlPointsEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, patch_control_points: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizerDiscardEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, rasterizer_discard_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBiasEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bias_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLogicOpEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op: LogicOp); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPrimitiveRestartEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_restart_enable: Bool32); +#[derive(Clone)] +pub struct ExtExtendedDynamicState2Fn { + pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT, + pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable, + pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable, + pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT, + pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable, +} +unsafe impl Send for ExtExtendedDynamicState2Fn {} +unsafe impl Sync for ExtExtendedDynamicState2Fn {} +impl ExtExtendedDynamicState2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_patch_control_points_ext: unsafe { + unsafe extern "system" fn cmd_set_patch_control_points_ext( + _command_buffer: CommandBuffer, + _patch_control_points: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_patch_control_points_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPatchControlPointsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_patch_control_points_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterizer_discard_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext( + _command_buffer: CommandBuffer, + _rasterizer_discard_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterizer_discard_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizerDiscardEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterizer_discard_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bias_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_bias_enable_ext( + _command_buffer: CommandBuffer, + _depth_bias_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bias_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBiasEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_logic_op_ext: unsafe { + unsafe extern "system" fn cmd_set_logic_op_ext( + _command_buffer: CommandBuffer, + _logic_op: LogicOp, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_logic_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_restart_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_primitive_restart_enable_ext( + _command_buffer: CommandBuffer, + _primitive_restart_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_restart_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveRestartEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_restart_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl DynamicState { + #[doc = "Not promoted to 1.3"] + pub const PATCH_CONTROL_POINTS_EXT: Self = Self(1_000_377_000); + pub const RASTERIZER_DISCARD_ENABLE_EXT: Self = Self::RASTERIZER_DISCARD_ENABLE; + pub const DEPTH_BIAS_ENABLE_EXT: Self = Self::DEPTH_BIAS_ENABLE; + #[doc = "Not promoted to 1.3"] + pub const LOGIC_OP_EXT: Self = Self(1_000_377_003); + pub const PRIMITIVE_RESTART_ENABLE_EXT: Self = Self::PRIMITIVE_RESTART_ENABLE; +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl StructureType { + #[doc = "Not promoted to 1.3"] + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self(1_000_377_000); +} +impl QnxScreenSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_screen_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateScreenSurfaceQNX = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const ScreenSurfaceCreateInfoQNX, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + window: *mut _screen_window, +) -> Bool32; +#[derive(Clone)] +pub struct QnxScreenSurfaceFn { + pub create_screen_surface_qnx: PFN_vkCreateScreenSurfaceQNX, + pub get_physical_device_screen_presentation_support_qnx: + PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX, +} +unsafe impl Send for QnxScreenSurfaceFn {} +unsafe impl Sync for QnxScreenSurfaceFn {} +impl QnxScreenSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_screen_surface_qnx: unsafe { + unsafe extern "system" fn create_screen_surface_qnx( + _instance: Instance, + _p_create_info: *const ScreenSurfaceCreateInfoQNX, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_screen_surface_qnx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateScreenSurfaceQNX\0"); + let val = _f(cname); + if val.is_null() { + create_screen_surface_qnx + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_screen_presentation_support_qnx: unsafe { + unsafe extern "system" fn get_physical_device_screen_presentation_support_qnx( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _window: *mut _screen_window, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_screen_presentation_support_qnx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceScreenPresentationSupportQNX\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_screen_presentation_support_qnx + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_QNX_screen_surface'"] +impl StructureType { + pub const SCREEN_SURFACE_CREATE_INFO_QNX: Self = Self(1_000_378_000); +} +impl KhrExtension380Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_380\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension380Fn {} +unsafe impl Send for KhrExtension380Fn {} +unsafe impl Sync for KhrExtension380Fn {} +impl KhrExtension380Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension381Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_381\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension381Fn {} +unsafe impl Send for KhrExtension381Fn {} +unsafe impl Sync for KhrExtension381Fn {} +impl KhrExtension381Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtColorWriteEnableFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_color_write_enable\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorWriteEnableEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + attachment_count: u32, + p_color_write_enables: *const Bool32, +); +#[derive(Clone)] +pub struct ExtColorWriteEnableFn { + pub cmd_set_color_write_enable_ext: PFN_vkCmdSetColorWriteEnableEXT, +} +unsafe impl Send for ExtColorWriteEnableFn {} +unsafe impl Sync for ExtColorWriteEnableFn {} +impl ExtColorWriteEnableFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_color_write_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_color_write_enable_ext( + _command_buffer: CommandBuffer, + _attachment_count: u32, + _p_color_write_enables: *const Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_write_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorWriteEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_write_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_color_write_enable'"] +impl DynamicState { + pub const COLOR_WRITE_ENABLE_EXT: Self = Self(1_000_381_000); +} +#[doc = "Generated from 'VK_EXT_color_write_enable'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: Self = Self(1_000_381_000); + pub const PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: Self = Self(1_000_381_001); +} +impl ExtPrimitivesGeneratedQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_primitives_generated_query\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPrimitivesGeneratedQueryFn {} +unsafe impl Send for ExtPrimitivesGeneratedQueryFn {} +unsafe impl Sync for ExtPrimitivesGeneratedQueryFn {} +impl ExtPrimitivesGeneratedQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_primitives_generated_query'"] +impl QueryType { + pub const PRIMITIVES_GENERATED_EXT: Self = Self(1_000_382_000); +} +#[doc = "Generated from 'VK_EXT_primitives_generated_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: Self = Self(1_000_382_000); +} +impl ExtExtension384Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_384\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension384Fn {} +unsafe impl Send for ExtExtension384Fn {} +unsafe impl Sync for ExtExtension384Fn {} +impl ExtExtension384Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl MesaExtension385Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_385\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct MesaExtension385Fn {} +unsafe impl Send for MesaExtension385Fn {} +unsafe impl Sync for MesaExtension385Fn {} +impl MesaExtension385Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension386Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_386\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension386Fn {} +unsafe impl Send for GoogleExtension386Fn {} +unsafe impl Sync for GoogleExtension386Fn {} +impl GoogleExtension386Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrRayTracingMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_maintenance1\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + indirect_device_address: DeviceAddress, +); +#[derive(Clone)] +pub struct KhrRayTracingMaintenance1Fn { + pub cmd_trace_rays_indirect2_khr: PFN_vkCmdTraceRaysIndirect2KHR, +} +unsafe impl Send for KhrRayTracingMaintenance1Fn {} +unsafe impl Sync for KhrRayTracingMaintenance1Fn {} +impl KhrRayTracingMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_trace_rays_indirect2_khr: unsafe { + unsafe extern "system" fn cmd_trace_rays_indirect2_khr( + _command_buffer: CommandBuffer, + _indirect_device_address: DeviceAddress, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_trace_rays_indirect2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdTraceRaysIndirect2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_indirect2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl AccessFlags2 { + pub const SHADER_BINDING_TABLE_READ_KHR: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl PipelineStageFlags2 { + pub const ACCELERATION_STRUCTURE_COPY_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl QueryType { + pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: Self = + Self(1_000_386_000); + pub const ACCELERATION_STRUCTURE_SIZE_KHR: Self = Self(1_000_386_001); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: Self = Self(1_000_386_000); +} +impl ExtExtension388Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_388\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension388Fn {} +unsafe impl Send for ExtExtension388Fn {} +unsafe impl Sync for ExtExtension388Fn {} +impl ExtExtension388Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtGlobalPriorityQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority_query\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtGlobalPriorityQueryFn {} +unsafe impl Send for ExtGlobalPriorityQueryFn {} +unsafe impl Sync for ExtGlobalPriorityQueryFn {} +impl ExtGlobalPriorityQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_global_priority_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR; + pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: Self = + Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR; +} +impl ExtExtension390Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_390\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension390Fn {} +unsafe impl Send for ExtExtension390Fn {} +unsafe impl Sync for ExtExtension390Fn {} +impl ExtExtension390Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension391Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_391\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension391Fn {} +unsafe impl Send for ExtExtension391Fn {} +unsafe impl Sync for ExtExtension391Fn {} +impl ExtExtension391Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtImageViewMinLodFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_view_min_lod\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtImageViewMinLodFn {} +unsafe impl Send for ExtImageViewMinLodFn {} +unsafe impl Sync for ExtImageViewMinLodFn {} +impl ExtImageViewMinLodFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_image_view_min_lod'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: Self = Self(1_000_391_000); + pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: Self = Self(1_000_391_001); +} +impl ExtMultiDrawFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_multi_draw\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMultiEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + draw_count: u32, + p_vertex_info: *const MultiDrawInfoEXT, + instance_count: u32, + first_instance: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMultiIndexedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + draw_count: u32, + p_index_info: *const MultiDrawIndexedInfoEXT, + instance_count: u32, + first_instance: u32, + stride: u32, + p_vertex_offset: *const i32, +); +#[derive(Clone)] +pub struct ExtMultiDrawFn { + pub cmd_draw_multi_ext: PFN_vkCmdDrawMultiEXT, + pub cmd_draw_multi_indexed_ext: PFN_vkCmdDrawMultiIndexedEXT, +} +unsafe impl Send for ExtMultiDrawFn {} +unsafe impl Sync for ExtMultiDrawFn {} +impl ExtMultiDrawFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_multi_ext: unsafe { + unsafe extern "system" fn cmd_draw_multi_ext( + _command_buffer: CommandBuffer, + _draw_count: u32, + _p_vertex_info: *const MultiDrawInfoEXT, + _instance_count: u32, + _first_instance: u32, + _stride: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_draw_multi_ext))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_multi_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_multi_indexed_ext: unsafe { + unsafe extern "system" fn cmd_draw_multi_indexed_ext( + _command_buffer: CommandBuffer, + _draw_count: u32, + _p_index_info: *const MultiDrawIndexedInfoEXT, + _instance_count: u32, + _first_instance: u32, + _stride: u32, + _p_vertex_offset: *const i32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_multi_indexed_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiIndexedEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_multi_indexed_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_multi_draw'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: Self = Self(1_000_392_000); + pub const PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: Self = Self(1_000_392_001); +} +impl ExtImage2dViewOf3dFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_2d_view_of_3d\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtImage2dViewOf3dFn {} +unsafe impl Send for ExtImage2dViewOf3dFn {} +unsafe impl Sync for ExtImage2dViewOf3dFn {} +impl ExtImage2dViewOf3dFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_image_2d_view_of_3d'"] +impl ImageCreateFlags { + #[doc = "Image is created with a layout where individual slices are capable of being used as 2D images"] + pub const TYPE_2D_VIEW_COMPATIBLE_EXT: Self = Self(0b10_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_image_2d_view_of_3d'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: Self = Self(1_000_393_000); +} +impl KhrPortabilityEnumerationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_enumeration\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrPortabilityEnumerationFn {} +unsafe impl Send for KhrPortabilityEnumerationFn {} +unsafe impl Sync for KhrPortabilityEnumerationFn {} +impl KhrPortabilityEnumerationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_portability_enumeration'"] +impl InstanceCreateFlags { + pub const ENUMERATE_PORTABILITY_KHR: Self = Self(0b1); +} +impl KhrExtension396Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_396\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension396Fn {} +unsafe impl Send for KhrExtension396Fn {} +unsafe impl Sync for KhrExtension396Fn {} +impl KhrExtension396Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtOpacityMicromapFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_opacity_micromap\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateMicromapEXT = unsafe extern "system" fn( + device: Device, + p_create_info: *const MicromapCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_micromap: *mut MicromapEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyMicromapEXT = unsafe extern "system" fn( + device: Device, + micromap: MicromapEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + info_count: u32, + p_infos: *const MicromapBuildInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBuildMicromapsEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + info_count: u32, + p_infos: *const MicromapBuildInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMicromapEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMicromapInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMicromapToMemoryInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMemoryToMicromapInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWriteMicromapsPropertiesEXT = unsafe extern "system" fn( + device: Device, + micromap_count: u32, + p_micromaps: *const MicromapEXT, + query_type: QueryType, + data_size: usize, + p_data: *mut c_void, + stride: usize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMicromapEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, p_info: *const CopyMicromapInfoEXT); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyMicromapToMemoryInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyMemoryToMicromapInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + micromap_count: u32, + p_micromaps: *const MicromapEXT, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn( + device: Device, + p_version_info: *const MicromapVersionInfoEXT, + p_compatibility: *mut AccelerationStructureCompatibilityKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn( + device: Device, + build_type: AccelerationStructureBuildTypeKHR, + p_build_info: *const MicromapBuildInfoEXT, + p_size_info: *mut MicromapBuildSizesInfoEXT, +); +#[derive(Clone)] +pub struct ExtOpacityMicromapFn { + pub create_micromap_ext: PFN_vkCreateMicromapEXT, + pub destroy_micromap_ext: PFN_vkDestroyMicromapEXT, + pub cmd_build_micromaps_ext: PFN_vkCmdBuildMicromapsEXT, + pub build_micromaps_ext: PFN_vkBuildMicromapsEXT, + pub copy_micromap_ext: PFN_vkCopyMicromapEXT, + pub copy_micromap_to_memory_ext: PFN_vkCopyMicromapToMemoryEXT, + pub copy_memory_to_micromap_ext: PFN_vkCopyMemoryToMicromapEXT, + pub write_micromaps_properties_ext: PFN_vkWriteMicromapsPropertiesEXT, + pub cmd_copy_micromap_ext: PFN_vkCmdCopyMicromapEXT, + pub cmd_copy_micromap_to_memory_ext: PFN_vkCmdCopyMicromapToMemoryEXT, + pub cmd_copy_memory_to_micromap_ext: PFN_vkCmdCopyMemoryToMicromapEXT, + pub cmd_write_micromaps_properties_ext: PFN_vkCmdWriteMicromapsPropertiesEXT, + pub get_device_micromap_compatibility_ext: PFN_vkGetDeviceMicromapCompatibilityEXT, + pub get_micromap_build_sizes_ext: PFN_vkGetMicromapBuildSizesEXT, +} +unsafe impl Send for ExtOpacityMicromapFn {} +unsafe impl Sync for ExtOpacityMicromapFn {} +impl ExtOpacityMicromapFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_micromap_ext: unsafe { + unsafe extern "system" fn create_micromap_ext( + _device: Device, + _p_create_info: *const MicromapCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_micromap: *mut MicromapEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_micromap_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + create_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_micromap_ext: unsafe { + unsafe extern "system" fn destroy_micromap_ext( + _device: Device, + _micromap: MicromapEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_micromap_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + destroy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_micromaps_ext: unsafe { + unsafe extern "system" fn cmd_build_micromaps_ext( + _command_buffer: CommandBuffer, + _info_count: u32, + _p_infos: *const MicromapBuildInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_micromaps_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBuildMicromapsEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_build_micromaps_ext + } else { + ::std::mem::transmute(val) + } + }, + build_micromaps_ext: unsafe { + unsafe extern "system" fn build_micromaps_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _info_count: u32, + _p_infos: *const MicromapBuildInfoEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(build_micromaps_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBuildMicromapsEXT\0"); + let val = _f(cname); + if val.is_null() { + build_micromaps_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_micromap_ext: unsafe { + unsafe extern "system" fn copy_micromap_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMicromapInfoEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(copy_micromap_ext))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_micromap_to_memory_ext: unsafe { + unsafe extern "system" fn copy_micromap_to_memory_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMicromapToMemoryInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_micromap_to_memory_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapToMemoryEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_micromap_to_memory_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_memory_to_micromap_ext: unsafe { + unsafe extern "system" fn copy_memory_to_micromap_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMemoryToMicromapInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_memory_to_micromap_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_memory_to_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + write_micromaps_properties_ext: unsafe { + unsafe extern "system" fn write_micromaps_properties_ext( + _device: Device, + _micromap_count: u32, + _p_micromaps: *const MicromapEXT, + _query_type: QueryType, + _data_size: usize, + _p_data: *mut c_void, + _stride: usize, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(write_micromaps_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkWriteMicromapsPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + write_micromaps_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_micromap_ext: unsafe { + unsafe extern "system" fn cmd_copy_micromap_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMicromapInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_micromap_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_micromap_to_memory_ext: unsafe { + unsafe extern "system" fn cmd_copy_micromap_to_memory_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMicromapToMemoryInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_micromap_to_memory_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMicromapToMemoryEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_micromap_to_memory_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_memory_to_micromap_ext: unsafe { + unsafe extern "system" fn cmd_copy_memory_to_micromap_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMemoryToMicromapInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_to_micromap_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMemoryToMicromapEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_to_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_micromaps_properties_ext: unsafe { + unsafe extern "system" fn cmd_write_micromaps_properties_ext( + _command_buffer: CommandBuffer, + _micromap_count: u32, + _p_micromaps: *const MicromapEXT, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_micromaps_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteMicromapsPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_micromaps_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + get_device_micromap_compatibility_ext: unsafe { + unsafe extern "system" fn get_device_micromap_compatibility_ext( + _device: Device, + _p_version_info: *const MicromapVersionInfoEXT, + _p_compatibility: *mut AccelerationStructureCompatibilityKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_micromap_compatibility_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMicromapCompatibilityEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_micromap_compatibility_ext + } else { + ::std::mem::transmute(val) + } + }, + get_micromap_build_sizes_ext: unsafe { + unsafe extern "system" fn get_micromap_build_sizes_ext( + _device: Device, + _build_type: AccelerationStructureBuildTypeKHR, + _p_build_info: *const MicromapBuildInfoEXT, + _p_size_info: *mut MicromapBuildSizesInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_micromap_build_sizes_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMicromapBuildSizesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_micromap_build_sizes_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl AccessFlags2 { + pub const MICROMAP_READ_EXT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const MICROMAP_WRITE_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl BufferUsageFlags { + pub const MICROMAP_BUILD_INPUT_READ_ONLY_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const MICROMAP_STORAGE_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_OPACITY_MICROMAP_UPDATE_EXT: Self = Self(0b100_0000); + pub const ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b1000_0000); + pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl GeometryInstanceFlagsKHR { + pub const FORCE_OPACITY_MICROMAP_2_STATE_EXT: Self = Self(0b1_0000); + pub const DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl ObjectType { + pub const MICROMAP_EXT: Self = Self(1_000_396_000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl PipelineStageFlags2 { + pub const MICROMAP_BUILD_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl QueryType { + pub const MICROMAP_SERIALIZATION_SIZE_EXT: Self = Self(1_000_396_000); + pub const MICROMAP_COMPACTED_SIZE_EXT: Self = Self(1_000_396_001); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl StructureType { + pub const MICROMAP_BUILD_INFO_EXT: Self = Self(1_000_396_000); + pub const MICROMAP_VERSION_INFO_EXT: Self = Self(1_000_396_001); + pub const COPY_MICROMAP_INFO_EXT: Self = Self(1_000_396_002); + pub const COPY_MICROMAP_TO_MEMORY_INFO_EXT: Self = Self(1_000_396_003); + pub const COPY_MEMORY_TO_MICROMAP_INFO_EXT: Self = Self(1_000_396_004); + pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: Self = Self(1_000_396_005); + pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: Self = Self(1_000_396_006); + pub const MICROMAP_CREATE_INFO_EXT: Self = Self(1_000_396_007); + pub const MICROMAP_BUILD_SIZES_INFO_EXT: Self = Self(1_000_396_008); + pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: Self = Self(1_000_396_009); +} +impl NvExtension398Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_398\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension398Fn {} +unsafe impl Send for NvExtension398Fn {} +unsafe impl Sync for NvExtension398Fn {} +impl NvExtension398Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_extension_398'"] +impl BuildAccelerationStructureFlagsKHR { + pub const RESERVED_9_NV: Self = Self(0b10_0000_0000); + pub const RESERVED_10_NV: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_NV_extension_398'"] +impl PipelineCreateFlags { + pub const RESERVED_28_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +impl JuiceExtension399Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_399\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct JuiceExtension399Fn {} +unsafe impl Send for JuiceExtension399Fn {} +unsafe impl Sync for JuiceExtension399Fn {} +impl JuiceExtension399Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl JuiceExtension400Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_400\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct JuiceExtension400Fn {} +unsafe impl Send for JuiceExtension400Fn {} +unsafe impl Sync for JuiceExtension400Fn {} +impl JuiceExtension400Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtLoadStoreOpNoneFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_load_store_op_none\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtLoadStoreOpNoneFn {} +unsafe impl Send for ExtLoadStoreOpNoneFn {} +unsafe impl Sync for ExtLoadStoreOpNoneFn {} +impl ExtLoadStoreOpNoneFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_load_store_op_none'"] +impl AttachmentLoadOp { + pub const NONE_EXT: Self = Self(1_000_400_000); +} +#[doc = "Generated from 'VK_EXT_load_store_op_none'"] +impl AttachmentStoreOp { + pub const NONE_EXT: Self = Self::NONE; +} +impl FbExtension402Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_402\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension402Fn {} +unsafe impl Send for FbExtension402Fn {} +unsafe impl Sync for FbExtension402Fn {} +impl FbExtension402Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FbExtension403Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_403\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension403Fn {} +unsafe impl Send for FbExtension403Fn {} +unsafe impl Sync for FbExtension403Fn {} +impl FbExtension403Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FbExtension404Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_404\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension404Fn {} +unsafe impl Send for FbExtension404Fn {} +unsafe impl Sync for FbExtension404Fn {} +impl FbExtension404Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl HuaweiExtension405Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_405\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension405Fn {} +unsafe impl Send for HuaweiExtension405Fn {} +unsafe impl Sync for HuaweiExtension405Fn {} +impl HuaweiExtension405Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_HUAWEI_extension_405'"] +impl PipelineStageFlags2 { + pub const RESEVED_41_HUAWEI: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_extension_405'"] +impl ShaderStageFlags { + pub const RESERVED_19_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000); +} +impl HuaweiExtension406Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_406\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension406Fn {} +unsafe impl Send for HuaweiExtension406Fn {} +unsafe impl Sync for HuaweiExtension406Fn {} +impl HuaweiExtension406Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension407Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_407\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension407Fn {} +unsafe impl Send for GgpExtension407Fn {} +unsafe impl Sync for GgpExtension407Fn {} +impl GgpExtension407Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension408Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_408\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension408Fn {} +unsafe impl Send for GgpExtension408Fn {} +unsafe impl Sync for GgpExtension408Fn {} +impl GgpExtension408Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension409Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_409\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension409Fn {} +unsafe impl Send for GgpExtension409Fn {} +unsafe impl Sync for GgpExtension409Fn {} +impl GgpExtension409Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension410Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_410\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension410Fn {} +unsafe impl Send for GgpExtension410Fn {} +unsafe impl Sync for GgpExtension410Fn {} +impl GgpExtension410Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension411Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_411\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension411Fn {} +unsafe impl Send for GgpExtension411Fn {} +unsafe impl Sync for GgpExtension411Fn {} +impl GgpExtension411Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtBorderColorSwizzleFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_border_color_swizzle\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtBorderColorSwizzleFn {} +unsafe impl Send for ExtBorderColorSwizzleFn {} +unsafe impl Sync for ExtBorderColorSwizzleFn {} +impl ExtBorderColorSwizzleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_border_color_swizzle'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: Self = Self(1_000_411_000); + pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: Self = Self(1_000_411_001); +} +impl ExtPageableDeviceLocalMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_pageable_device_local_memory\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetDeviceMemoryPriorityEXT = + unsafe extern "system" fn(device: Device, memory: DeviceMemory, priority: f32); +#[derive(Clone)] +pub struct ExtPageableDeviceLocalMemoryFn { + pub set_device_memory_priority_ext: PFN_vkSetDeviceMemoryPriorityEXT, +} +unsafe impl Send for ExtPageableDeviceLocalMemoryFn {} +unsafe impl Sync for ExtPageableDeviceLocalMemoryFn {} +impl ExtPageableDeviceLocalMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_device_memory_priority_ext: unsafe { + unsafe extern "system" fn set_device_memory_priority_ext( + _device: Device, + _memory: DeviceMemory, + _priority: f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(set_device_memory_priority_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetDeviceMemoryPriorityEXT\0", + ); + let val = _f(cname); + if val.is_null() { + set_device_memory_priority_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_pageable_device_local_memory'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: Self = Self(1_000_412_000); +} +impl KhrMaintenance4Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance4\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceBufferMemoryRequirements, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceImageMemoryRequirements, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceImageMemoryRequirements, + p_sparse_memory_requirement_count: *mut u32, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, +); +#[derive(Clone)] +pub struct KhrMaintenance4Fn { + pub get_device_buffer_memory_requirements_khr: PFN_vkGetDeviceBufferMemoryRequirements, + pub get_device_image_memory_requirements_khr: PFN_vkGetDeviceImageMemoryRequirements, + pub get_device_image_sparse_memory_requirements_khr: + PFN_vkGetDeviceImageSparseMemoryRequirements, +} +unsafe impl Send for KhrMaintenance4Fn {} +unsafe impl Sync for KhrMaintenance4Fn {} +impl KhrMaintenance4Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_device_buffer_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_buffer_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceBufferMemoryRequirements, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_buffer_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceBufferMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_buffer_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_image_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceImageMemoryRequirements, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_sparse_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_image_sparse_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceImageMemoryRequirements, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_sparse_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageSparseMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_sparse_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_maintenance4'"] +impl ImageAspectFlags { + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_maintenance4'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; + pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS; + pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS; +} +impl HuaweiExtension415Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_415\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension415Fn {} +unsafe impl Send for HuaweiExtension415Fn {} +unsafe impl Sync for HuaweiExtension415Fn {} +impl HuaweiExtension415Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension416Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_416\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension416Fn {} +unsafe impl Send for ArmExtension416Fn {} +unsafe impl Sync for ArmExtension416Fn {} +impl ArmExtension416Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension417Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_417\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension417Fn {} +unsafe impl Send for KhrExtension417Fn {} +unsafe impl Sync for KhrExtension417Fn {} +impl KhrExtension417Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension418Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_418\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension418Fn {} +unsafe impl Send for ArmExtension418Fn {} +unsafe impl Sync for ArmExtension418Fn {} +impl ArmExtension418Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension419Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_419\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension419Fn {} +unsafe impl Send for ExtExtension419Fn {} +unsafe impl Sync for ExtExtension419Fn {} +impl ExtExtension419Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_419'"] +impl ImageViewCreateFlags { + pub const RESERVED_3_EXT: Self = Self(0b1000); +} +impl ExtExtension420Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_420\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension420Fn {} +unsafe impl Send for ExtExtension420Fn {} +unsafe impl Sync for ExtExtension420Fn {} +impl ExtExtension420Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_420'"] +impl SwapchainCreateFlagsKHR { + pub const RESERVED_4_EXT: Self = Self(0b1_0000); +} +impl ValveDescriptorSetHostMappingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_VALVE_descriptor_set_host_mapping\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn( + device: Device, + p_binding_reference: *const DescriptorSetBindingReferenceVALVE, + p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn( + device: Device, + descriptor_set: DescriptorSet, + pp_data: *mut *mut c_void, +); +#[derive(Clone)] +pub struct ValveDescriptorSetHostMappingFn { + pub get_descriptor_set_layout_host_mapping_info_valve: + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE, + pub get_descriptor_set_host_mapping_valve: PFN_vkGetDescriptorSetHostMappingVALVE, +} +unsafe impl Send for ValveDescriptorSetHostMappingFn {} +unsafe impl Sync for ValveDescriptorSetHostMappingFn {} +impl ValveDescriptorSetHostMappingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_descriptor_set_layout_host_mapping_info_valve: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_host_mapping_info_valve( + _device: Device, + _p_binding_reference: *const DescriptorSetBindingReferenceVALVE, + _p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_host_mapping_info_valve) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutHostMappingInfoVALVE\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_host_mapping_info_valve + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_host_mapping_valve: unsafe { + unsafe extern "system" fn get_descriptor_set_host_mapping_valve( + _device: Device, + _descriptor_set: DescriptorSet, + _pp_data: *mut *mut c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_host_mapping_valve) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetHostMappingVALVE\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_host_mapping_valve + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_VALVE_descriptor_set_host_mapping'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: Self = + Self(1_000_420_000); + pub const DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: Self = Self(1_000_420_001); + pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: Self = Self(1_000_420_002); +} +impl ExtDepthClampZeroOneFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clamp_zero_one\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDepthClampZeroOneFn {} +unsafe impl Send for ExtDepthClampZeroOneFn {} +unsafe impl Sync for ExtDepthClampZeroOneFn {} +impl ExtDepthClampZeroOneFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_depth_clamp_zero_one'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: Self = Self(1_000_421_000); +} +impl ExtNonSeamlessCubeMapFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_non_seamless_cube_map\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtNonSeamlessCubeMapFn {} +unsafe impl Send for ExtNonSeamlessCubeMapFn {} +unsafe impl Sync for ExtNonSeamlessCubeMapFn {} +impl ExtNonSeamlessCubeMapFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"] +impl SamplerCreateFlags { + pub const NON_SEAMLESS_CUBE_MAP_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"] +impl StructureType { + pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: Self = Self(1_000_422_000); +} +impl ArmExtension424Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_424\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension424Fn {} +unsafe impl Send for ArmExtension424Fn {} +unsafe impl Sync for ArmExtension424Fn {} +impl ArmExtension424Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension425Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_425\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension425Fn {} +unsafe impl Send for ArmExtension425Fn {} +unsafe impl Sync for ArmExtension425Fn {} +impl ArmExtension425Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomFragmentDensityMapOffsetFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_QCOM_fragment_density_map_offset\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomFragmentDensityMapOffsetFn {} +unsafe impl Send for QcomFragmentDensityMapOffsetFn {} +unsafe impl Sync for QcomFragmentDensityMapOffsetFn {} +impl QcomFragmentDensityMapOffsetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"] +impl ImageCreateFlags { + pub const FRAGMENT_DENSITY_MAP_OFFSET_QCOM: Self = Self(0b1000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: Self = Self(1_000_425_000); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: Self = + Self(1_000_425_001); + pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: Self = Self(1_000_425_002); +} +impl NvCopyMemoryIndirectFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_copy_memory_indirect\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + copy_buffer_address: DeviceAddress, + copy_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + copy_buffer_address: DeviceAddress, + copy_count: u32, + stride: u32, + dst_image: Image, + dst_image_layout: ImageLayout, + p_image_subresources: *const ImageSubresourceLayers, +); +#[derive(Clone)] +pub struct NvCopyMemoryIndirectFn { + pub cmd_copy_memory_indirect_nv: PFN_vkCmdCopyMemoryIndirectNV, + pub cmd_copy_memory_to_image_indirect_nv: PFN_vkCmdCopyMemoryToImageIndirectNV, +} +unsafe impl Send for NvCopyMemoryIndirectFn {} +unsafe impl Sync for NvCopyMemoryIndirectFn {} +impl NvCopyMemoryIndirectFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_copy_memory_indirect_nv: unsafe { + unsafe extern "system" fn cmd_copy_memory_indirect_nv( + _command_buffer: CommandBuffer, + _copy_buffer_address: DeviceAddress, + _copy_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_indirect_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryIndirectNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_memory_to_image_indirect_nv: unsafe { + unsafe extern "system" fn cmd_copy_memory_to_image_indirect_nv( + _command_buffer: CommandBuffer, + _copy_buffer_address: DeviceAddress, + _copy_count: u32, + _stride: u32, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _p_image_subresources: *const ImageSubresourceLayers, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_to_image_indirect_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMemoryToImageIndirectNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_to_image_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_copy_memory_indirect'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: Self = Self(1_000_426_000); + pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: Self = Self(1_000_426_001); +} +impl NvMemoryDecompressionFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_memory_decompression\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDecompressMemoryNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + decompress_region_count: u32, + p_decompress_memory_regions: *const DecompressMemoryRegionNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + indirect_commands_address: DeviceAddress, + indirect_commands_count_address: DeviceAddress, + stride: u32, +); +#[derive(Clone)] +pub struct NvMemoryDecompressionFn { + pub cmd_decompress_memory_nv: PFN_vkCmdDecompressMemoryNV, + pub cmd_decompress_memory_indirect_count_nv: PFN_vkCmdDecompressMemoryIndirectCountNV, +} +unsafe impl Send for NvMemoryDecompressionFn {} +unsafe impl Sync for NvMemoryDecompressionFn {} +impl NvMemoryDecompressionFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_decompress_memory_nv: unsafe { + unsafe extern "system" fn cmd_decompress_memory_nv( + _command_buffer: CommandBuffer, + _decompress_region_count: u32, + _p_decompress_memory_regions: *const DecompressMemoryRegionNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_decompress_memory_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecompressMemoryNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_decompress_memory_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_decompress_memory_indirect_count_nv: unsafe { + unsafe extern "system" fn cmd_decompress_memory_indirect_count_nv( + _command_buffer: CommandBuffer, + _indirect_commands_address: DeviceAddress, + _indirect_commands_count_address: DeviceAddress, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_decompress_memory_indirect_count_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDecompressMemoryIndirectCountNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_decompress_memory_indirect_count_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_memory_decompression'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: Self = Self(1_000_427_000); + pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: Self = Self(1_000_427_001); +} +impl NvExtension429Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_429\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension429Fn {} +unsafe impl Send for NvExtension429Fn {} +unsafe impl Sync for NvExtension429Fn {} +impl NvExtension429Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension430Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_430\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension430Fn {} +unsafe impl Send for NvExtension430Fn {} +unsafe impl Sync for NvExtension430Fn {} +impl NvExtension430Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvLinearColorAttachmentFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_linear_color_attachment\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvLinearColorAttachmentFn {} +unsafe impl Send for NvLinearColorAttachmentFn {} +unsafe impl Sync for NvLinearColorAttachmentFn {} +impl NvLinearColorAttachmentFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_linear_color_attachment'"] +impl FormatFeatureFlags2 { + #[doc = "Format support linear image as render target, it cannot be mixed with non linear attachment"] + pub const LINEAR_COLOR_ATTACHMENT_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_linear_color_attachment'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: Self = Self(1_000_430_000); +} +impl NvExtension432Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_432\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension432Fn {} +unsafe impl Send for NvExtension432Fn {} +unsafe impl Sync for NvExtension432Fn {} +impl NvExtension432Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension433Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_433\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension433Fn {} +unsafe impl Send for NvExtension433Fn {} +unsafe impl Sync for NvExtension433Fn {} +impl NvExtension433Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleSurfacelessQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_surfaceless_query\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct GoogleSurfacelessQueryFn {} +unsafe impl Send for GoogleSurfacelessQueryFn {} +unsafe impl Sync for GoogleSurfacelessQueryFn {} +impl GoogleSurfacelessQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension435Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_435\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension435Fn {} +unsafe impl Send for KhrExtension435Fn {} +unsafe impl Sync for KhrExtension435Fn {} +impl KhrExtension435Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension436Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_436\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension436Fn {} +unsafe impl Send for NvExtension436Fn {} +unsafe impl Sync for NvExtension436Fn {} +impl NvExtension436Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension437Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_437\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension437Fn {} +unsafe impl Send for ExtExtension437Fn {} +unsafe impl Sync for ExtExtension437Fn {} +impl ExtExtension437Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtImageCompressionControlSwapchainFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_image_compression_control_swapchain\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtImageCompressionControlSwapchainFn {} +unsafe impl Send for ExtImageCompressionControlSwapchainFn {} +unsafe impl Sync for ExtImageCompressionControlSwapchainFn {} +impl ExtImageCompressionControlSwapchainFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_image_compression_control_swapchain'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: Self = + Self(1_000_437_000); +} +impl SecExtension439Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_439\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension439Fn {} +unsafe impl Send for SecExtension439Fn {} +unsafe impl Sync for SecExtension439Fn {} +impl SecExtension439Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension440Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_440\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension440Fn {} +unsafe impl Send for QcomExtension440Fn {} +unsafe impl Sync for QcomExtension440Fn {} +impl QcomExtension440Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_440'"] +impl DeviceQueueCreateFlags { + pub const RESERVED_1_QCOM: Self = Self(0b10); +} +#[doc = "Generated from 'VK_QCOM_extension_440'"] +impl QueueFlags { + pub const RESERVED_7_QCOM: Self = Self(0b1000_0000); +} +impl QcomImageProcessingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_image_processing\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomImageProcessingFn {} +unsafe impl Send for QcomImageProcessingFn {} +unsafe impl Sync for QcomImageProcessingFn {} +impl QcomImageProcessingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl DescriptorType { + pub const SAMPLE_WEIGHT_IMAGE_QCOM: Self = Self(1_000_440_000); + pub const BLOCK_MATCH_IMAGE_QCOM: Self = Self(1_000_440_001); +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl FormatFeatureFlags2 { + pub const WEIGHT_IMAGE_QCOM: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); + pub const WEIGHT_SAMPLED_IMAGE_QCOM: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const BLOCK_MATCHING_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const BOX_FILTER_SAMPLED_QCOM: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl ImageUsageFlags { + pub const SAMPLE_WEIGHT_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const SAMPLE_BLOCK_MATCH_QCOM: Self = Self(0b10_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl SamplerCreateFlags { + pub const IMAGE_PROCESSING_QCOM: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: Self = Self(1_000_440_000); + pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: Self = Self(1_000_440_001); + pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: Self = Self(1_000_440_002); +} +impl CoreaviExtension442Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_442\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension442Fn {} +unsafe impl Send for CoreaviExtension442Fn {} +unsafe impl Sync for CoreaviExtension442Fn {} +impl CoreaviExtension442Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension443Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_443\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension443Fn {} +unsafe impl Send for CoreaviExtension443Fn {} +unsafe impl Sync for CoreaviExtension443Fn {} +impl CoreaviExtension443Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension444Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_444\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension444Fn {} +unsafe impl Send for CoreaviExtension444Fn {} +unsafe impl Sync for CoreaviExtension444Fn {} +impl CoreaviExtension444Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_COREAVI_extension_444'"] +impl CommandPoolResetFlags { + pub const RESERVED_1_COREAVI: Self = Self(0b10); +} +impl CoreaviExtension445Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_445\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension445Fn {} +unsafe impl Send for CoreaviExtension445Fn {} +unsafe impl Sync for CoreaviExtension445Fn {} +impl CoreaviExtension445Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension446Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_446\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension446Fn {} +unsafe impl Send for CoreaviExtension446Fn {} +unsafe impl Sync for CoreaviExtension446Fn {} +impl CoreaviExtension446Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension447Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_447\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension447Fn {} +unsafe impl Send for CoreaviExtension447Fn {} +unsafe impl Sync for CoreaviExtension447Fn {} +impl CoreaviExtension447Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension448Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_448\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension448Fn {} +unsafe impl Send for SecExtension448Fn {} +unsafe impl Sync for SecExtension448Fn {} +impl SecExtension448Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension449Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_449\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension449Fn {} +unsafe impl Send for SecExtension449Fn {} +unsafe impl Sync for SecExtension449Fn {} +impl SecExtension449Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension450Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_450\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension450Fn {} +unsafe impl Send for SecExtension450Fn {} +unsafe impl Sync for SecExtension450Fn {} +impl SecExtension450Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension451Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_451\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension451Fn {} +unsafe impl Send for SecExtension451Fn {} +unsafe impl Sync for SecExtension451Fn {} +impl SecExtension451Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension452Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_452\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension452Fn {} +unsafe impl Send for NvExtension452Fn {} +unsafe impl Sync for NvExtension452Fn {} +impl NvExtension452Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension453Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_453\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension453Fn {} +unsafe impl Send for ArmExtension453Fn {} +unsafe impl Sync for ArmExtension453Fn {} +impl ArmExtension453Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension454Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_454\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension454Fn {} +unsafe impl Send for GoogleExtension454Fn {} +unsafe impl Sync for GoogleExtension454Fn {} +impl GoogleExtension454Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension455Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_455\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension455Fn {} +unsafe impl Send for GoogleExtension455Fn {} +unsafe impl Sync for GoogleExtension455Fn {} +impl GoogleExtension455Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtendedDynamicState3Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state3\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + domain_origin: TessellationDomainOrigin, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClampEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clamp_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPolygonModeEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, polygon_mode: PolygonMode); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + rasterization_samples: SampleCountFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + samples: SampleCountFlags, + p_sample_mask: *const SampleMask, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetAlphaToCoverageEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_coverage_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetAlphaToOneEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_one_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLogicOpEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_enables: *const Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_equations: *const ColorBlendEquationEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_write_masks: *const ColorComponentFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizationStreamEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, rasterization_stream: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + conservative_rasterization_mode: ConservativeRasterizationModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + extra_primitive_overestimation_size: f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClipEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clip_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetSampleLocationsEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, sample_locations_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_advanced: *const ColorBlendAdvancedEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + provoking_vertex_mode: ProvokingVertexModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + line_rasterization_mode: LineRasterizationModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineStippleEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, stippled_line_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, negative_one_to_one: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportWScalingEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, viewport_w_scaling_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_viewport_swizzles: *const ViewportSwizzleNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageToColorEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageToColorLocationNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_location: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_mode: CoverageModulationModeNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_table_enable: Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_table_count: u32, + p_coverage_modulation_table: *const f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetShadingRateImageEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, shading_rate_image_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + representative_fragment_test_enable: Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_reduction_mode: CoverageReductionModeNV, +); +#[derive(Clone)] +pub struct ExtExtendedDynamicState3Fn { + pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEXT, + pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT, + pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT, + pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT, + pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT, + pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT, + pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT, + pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT, + pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT, + pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT, + pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT, + pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT, + pub cmd_set_conservative_rasterization_mode_ext: PFN_vkCmdSetConservativeRasterizationModeEXT, + pub cmd_set_extra_primitive_overestimation_size_ext: + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT, + pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT, + pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT, + pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT, + pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT, + pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT, + pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT, + pub cmd_set_depth_clip_negative_one_to_one_ext: PFN_vkCmdSetDepthClipNegativeOneToOneEXT, + pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV, + pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV, + pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV, + pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV, + pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV, + pub cmd_set_coverage_modulation_table_enable_nv: PFN_vkCmdSetCoverageModulationTableEnableNV, + pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV, + pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV, + pub cmd_set_representative_fragment_test_enable_nv: + PFN_vkCmdSetRepresentativeFragmentTestEnableNV, + pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV, +} +unsafe impl Send for ExtExtendedDynamicState3Fn {} +unsafe impl Sync for ExtExtendedDynamicState3Fn {} +impl ExtExtendedDynamicState3Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_tessellation_domain_origin_ext: unsafe { + unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext( + _command_buffer: CommandBuffer, + _domain_origin: TessellationDomainOrigin, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_tessellation_domain_origin_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetTessellationDomainOriginEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_tessellation_domain_origin_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clamp_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clamp_enable_ext( + _command_buffer: CommandBuffer, + _depth_clamp_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clamp_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClampEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clamp_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_polygon_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_polygon_mode_ext( + _command_buffer: CommandBuffer, + _polygon_mode: PolygonMode, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_polygon_mode_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_polygon_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterization_samples_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterization_samples_ext( + _command_buffer: CommandBuffer, + _rasterization_samples: SampleCountFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterization_samples_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizationSamplesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterization_samples_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_sample_mask_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_mask_ext( + _command_buffer: CommandBuffer, + _samples: SampleCountFlags, + _p_sample_mask: *const SampleMask, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_mask_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_mask_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_alpha_to_coverage_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext( + _command_buffer: CommandBuffer, + _alpha_to_coverage_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_alpha_to_coverage_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetAlphaToCoverageEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_alpha_to_coverage_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_alpha_to_one_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext( + _command_buffer: CommandBuffer, + _alpha_to_one_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_alpha_to_one_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetAlphaToOneEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_alpha_to_one_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_logic_op_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_logic_op_enable_ext( + _command_buffer: CommandBuffer, + _logic_op_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_logic_op_enable_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_logic_op_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_enable_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_enables: *const Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_equation_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_equation_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_equations: *const ColorBlendEquationEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_equation_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendEquationEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_equation_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_write_mask_ext: unsafe { + unsafe extern "system" fn cmd_set_color_write_mask_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_write_masks: *const ColorComponentFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_write_mask_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_color_write_mask_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterization_stream_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterization_stream_ext( + _command_buffer: CommandBuffer, + _rasterization_stream: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterization_stream_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizationStreamEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterization_stream_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_conservative_rasterization_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext( + _command_buffer: CommandBuffer, + _conservative_rasterization_mode: ConservativeRasterizationModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_conservative_rasterization_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetConservativeRasterizationModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_conservative_rasterization_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_extra_primitive_overestimation_size_ext: unsafe { + unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext( + _command_buffer: CommandBuffer, + _extra_primitive_overestimation_size: f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_extra_primitive_overestimation_size_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_extra_primitive_overestimation_size_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clip_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clip_enable_ext( + _command_buffer: CommandBuffer, + _depth_clip_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clip_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClipEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clip_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_sample_locations_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_locations_enable_ext( + _command_buffer: CommandBuffer, + _sample_locations_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_locations_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetSampleLocationsEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_locations_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_advanced_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_advanced_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_advanced: *const ColorBlendAdvancedEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_advanced_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendAdvancedEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_advanced_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_provoking_vertex_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext( + _command_buffer: CommandBuffer, + _provoking_vertex_mode: ProvokingVertexModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_provoking_vertex_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetProvokingVertexModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_provoking_vertex_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_rasterization_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_line_rasterization_mode_ext( + _command_buffer: CommandBuffer, + _line_rasterization_mode: LineRasterizationModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_rasterization_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetLineRasterizationModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_line_rasterization_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_stipple_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_line_stipple_enable_ext( + _command_buffer: CommandBuffer, + _stippled_line_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_stipple_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetLineStippleEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_line_stipple_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clip_negative_one_to_one_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext( + _command_buffer: CommandBuffer, + _negative_one_to_one: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clip_negative_one_to_one_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClipNegativeOneToOneEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clip_negative_one_to_one_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_w_scaling_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv( + _command_buffer: CommandBuffer, + _viewport_w_scaling_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_w_scaling_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWScalingEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_w_scaling_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_swizzle_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_swizzle_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewport_swizzles: *const ViewportSwizzleNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_swizzle_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_swizzle_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_to_color_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv( + _command_buffer: CommandBuffer, + _coverage_to_color_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_to_color_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageToColorEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_to_color_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_to_color_location_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_to_color_location_nv( + _command_buffer: CommandBuffer, + _coverage_to_color_location: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_to_color_location_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageToColorLocationNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_to_color_location_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_mode_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_mode: CoverageModulationModeNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_mode_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationModeNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_table_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_table_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_table_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationTableEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_table_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_table_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_table_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_table_count: u32, + _p_coverage_modulation_table: *const f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_table_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationTableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_table_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_shading_rate_image_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv( + _command_buffer: CommandBuffer, + _shading_rate_image_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_shading_rate_image_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetShadingRateImageEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_shading_rate_image_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_representative_fragment_test_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv( + _command_buffer: CommandBuffer, + _representative_fragment_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_representative_fragment_test_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRepresentativeFragmentTestEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_representative_fragment_test_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_reduction_mode_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv( + _command_buffer: CommandBuffer, + _coverage_reduction_mode: CoverageReductionModeNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_reduction_mode_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageReductionModeNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_reduction_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"] +impl DynamicState { + pub const TESSELLATION_DOMAIN_ORIGIN_EXT: Self = Self(1_000_455_002); + pub const DEPTH_CLAMP_ENABLE_EXT: Self = Self(1_000_455_003); + pub const POLYGON_MODE_EXT: Self = Self(1_000_455_004); + pub const RASTERIZATION_SAMPLES_EXT: Self = Self(1_000_455_005); + pub const SAMPLE_MASK_EXT: Self = Self(1_000_455_006); + pub const ALPHA_TO_COVERAGE_ENABLE_EXT: Self = Self(1_000_455_007); + pub const ALPHA_TO_ONE_ENABLE_EXT: Self = Self(1_000_455_008); + pub const LOGIC_OP_ENABLE_EXT: Self = Self(1_000_455_009); + pub const COLOR_BLEND_ENABLE_EXT: Self = Self(1_000_455_010); + pub const COLOR_BLEND_EQUATION_EXT: Self = Self(1_000_455_011); + pub const COLOR_WRITE_MASK_EXT: Self = Self(1_000_455_012); + pub const RASTERIZATION_STREAM_EXT: Self = Self(1_000_455_013); + pub const CONSERVATIVE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_014); + pub const EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: Self = Self(1_000_455_015); + pub const DEPTH_CLIP_ENABLE_EXT: Self = Self(1_000_455_016); + pub const SAMPLE_LOCATIONS_ENABLE_EXT: Self = Self(1_000_455_017); + pub const COLOR_BLEND_ADVANCED_EXT: Self = Self(1_000_455_018); + pub const PROVOKING_VERTEX_MODE_EXT: Self = Self(1_000_455_019); + pub const LINE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_020); + pub const LINE_STIPPLE_ENABLE_EXT: Self = Self(1_000_455_021); + pub const DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: Self = Self(1_000_455_022); + pub const VIEWPORT_W_SCALING_ENABLE_NV: Self = Self(1_000_455_023); + pub const VIEWPORT_SWIZZLE_NV: Self = Self(1_000_455_024); + pub const COVERAGE_TO_COLOR_ENABLE_NV: Self = Self(1_000_455_025); + pub const COVERAGE_TO_COLOR_LOCATION_NV: Self = Self(1_000_455_026); + pub const COVERAGE_MODULATION_MODE_NV: Self = Self(1_000_455_027); + pub const COVERAGE_MODULATION_TABLE_ENABLE_NV: Self = Self(1_000_455_028); + pub const COVERAGE_MODULATION_TABLE_NV: Self = Self(1_000_455_029); + pub const SHADING_RATE_IMAGE_ENABLE_NV: Self = Self(1_000_455_030); + pub const REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: Self = Self(1_000_455_031); + pub const COVERAGE_REDUCTION_MODE_NV: Self = Self(1_000_455_032); +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: Self = Self(1_000_455_000); + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: Self = Self(1_000_455_001); +} +impl ExtExtension457Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_457\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension457Fn {} +unsafe impl Send for ExtExtension457Fn {} +unsafe impl Sync for ExtExtension457Fn {} +impl ExtExtension457Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension458Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_458\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension458Fn {} +unsafe impl Send for ExtExtension458Fn {} +unsafe impl Sync for ExtExtension458Fn {} +impl ExtExtension458Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtSubpassMergeFeedbackFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subpass_merge_feedback\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtSubpassMergeFeedbackFn {} +unsafe impl Send for ExtSubpassMergeFeedbackFn {} +unsafe impl Sync for ExtSubpassMergeFeedbackFn {} +impl ExtSubpassMergeFeedbackFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_subpass_merge_feedback'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: Self = Self(1_000_458_000); + pub const RENDER_PASS_CREATION_CONTROL_EXT: Self = Self(1_000_458_001); + pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_002); + pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_003); +} +impl LunargDirectDriverLoadingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_LUNARG_direct_driver_loading\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct LunargDirectDriverLoadingFn {} +unsafe impl Send for LunargDirectDriverLoadingFn {} +unsafe impl Sync for LunargDirectDriverLoadingFn {} +impl LunargDirectDriverLoadingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_LUNARG_direct_driver_loading'"] +impl StructureType { + pub const DIRECT_DRIVER_LOADING_INFO_LUNARG: Self = Self(1_000_459_000); + pub const DIRECT_DRIVER_LOADING_LIST_LUNARG: Self = Self(1_000_459_001); +} +impl ExtExtension461Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_461\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension461Fn {} +unsafe impl Send for ExtExtension461Fn {} +unsafe impl Sync for ExtExtension461Fn {} +impl ExtExtension461Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_461'"] +impl FormatFeatureFlags2 { + pub const RESERVED_39_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +impl ExtExtension462Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_462\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension462Fn {} +unsafe impl Send for ExtExtension462Fn {} +unsafe impl Sync for ExtExtension462Fn {} +impl ExtExtension462Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderModuleIdentifierFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_module_identifier\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn( + device: Device, + shader_module: ShaderModule, + p_identifier: *mut ShaderModuleIdentifierEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn( + device: Device, + p_create_info: *const ShaderModuleCreateInfo, + p_identifier: *mut ShaderModuleIdentifierEXT, +); +#[derive(Clone)] +pub struct ExtShaderModuleIdentifierFn { + pub get_shader_module_identifier_ext: PFN_vkGetShaderModuleIdentifierEXT, + pub get_shader_module_create_info_identifier_ext: PFN_vkGetShaderModuleCreateInfoIdentifierEXT, +} +unsafe impl Send for ExtShaderModuleIdentifierFn {} +unsafe impl Sync for ExtShaderModuleIdentifierFn {} +impl ExtShaderModuleIdentifierFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_shader_module_identifier_ext: unsafe { + unsafe extern "system" fn get_shader_module_identifier_ext( + _device: Device, + _shader_module: ShaderModule, + _p_identifier: *mut ShaderModuleIdentifierEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_shader_module_identifier_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetShaderModuleIdentifierEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_shader_module_identifier_ext + } else { + ::std::mem::transmute(val) + } + }, + get_shader_module_create_info_identifier_ext: unsafe { + unsafe extern "system" fn get_shader_module_create_info_identifier_ext( + _device: Device, + _p_create_info: *const ShaderModuleCreateInfo, + _p_identifier: *mut ShaderModuleIdentifierEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_shader_module_create_info_identifier_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetShaderModuleCreateInfoIdentifierEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_shader_module_create_info_identifier_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_shader_module_identifier'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: Self = Self(1_000_462_000); + pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: Self = Self(1_000_462_001); + pub const PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: Self = Self(1_000_462_002); + pub const SHADER_MODULE_IDENTIFIER_EXT: Self = Self(1_000_462_003); +} +impl ExtRasterizationOrderAttachmentAccessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_rasterization_order_attachment_access\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtRasterizationOrderAttachmentAccessFn {} +unsafe impl Send for ExtRasterizationOrderAttachmentAccessFn {} +unsafe impl Sync for ExtRasterizationOrderAttachmentAccessFn {} +impl ExtRasterizationOrderAttachmentAccessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"] +impl PipelineColorBlendStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT: Self = Self(0b1); +} +#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"] +impl PipelineDepthStencilStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b1); + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b10); +} +#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: Self = + Self(1_000_342_000); +} +#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"] +impl SubpassDescriptionFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT: Self = Self(0b1_0000); + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b10_0000); + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b100_0000); +} +impl NvOpticalFlowFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_optical_flow\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV, + p_format_count: *mut u32, + p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const OpticalFlowSessionCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_session: *mut OpticalFlowSessionNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn( + device: Device, + session: OpticalFlowSessionNV, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn( + device: Device, + session: OpticalFlowSessionNV, + binding_point: OpticalFlowSessionBindingPointNV, + view: ImageView, + layout: ImageLayout, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + session: OpticalFlowSessionNV, + p_execute_info: *const OpticalFlowExecuteInfoNV, +); +#[derive(Clone)] +pub struct NvOpticalFlowFn { + pub get_physical_device_optical_flow_image_formats_nv: + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV, + pub create_optical_flow_session_nv: PFN_vkCreateOpticalFlowSessionNV, + pub destroy_optical_flow_session_nv: PFN_vkDestroyOpticalFlowSessionNV, + pub bind_optical_flow_session_image_nv: PFN_vkBindOpticalFlowSessionImageNV, + pub cmd_optical_flow_execute_nv: PFN_vkCmdOpticalFlowExecuteNV, +} +unsafe impl Send for NvOpticalFlowFn {} +unsafe impl Sync for NvOpticalFlowFn {} +impl NvOpticalFlowFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_optical_flow_image_formats_nv: unsafe { + unsafe extern "system" fn get_physical_device_optical_flow_image_formats_nv( + _physical_device: PhysicalDevice, + _p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV, + _p_format_count: *mut u32, + _p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_optical_flow_image_formats_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceOpticalFlowImageFormatsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_optical_flow_image_formats_nv + } else { + ::std::mem::transmute(val) + } + }, + create_optical_flow_session_nv: unsafe { + unsafe extern "system" fn create_optical_flow_session_nv( + _device: Device, + _p_create_info: *const OpticalFlowSessionCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_session: *mut OpticalFlowSessionNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_optical_flow_session_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateOpticalFlowSessionNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_optical_flow_session_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_optical_flow_session_nv: unsafe { + unsafe extern "system" fn destroy_optical_flow_session_nv( + _device: Device, + _session: OpticalFlowSessionNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_optical_flow_session_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyOpticalFlowSessionNV\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_optical_flow_session_nv + } else { + ::std::mem::transmute(val) + } + }, + bind_optical_flow_session_image_nv: unsafe { + unsafe extern "system" fn bind_optical_flow_session_image_nv( + _device: Device, + _session: OpticalFlowSessionNV, + _binding_point: OpticalFlowSessionBindingPointNV, + _view: ImageView, + _layout: ImageLayout, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_optical_flow_session_image_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBindOpticalFlowSessionImageNV\0", + ); + let val = _f(cname); + if val.is_null() { + bind_optical_flow_session_image_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_optical_flow_execute_nv: unsafe { + unsafe extern "system" fn cmd_optical_flow_execute_nv( + _command_buffer: CommandBuffer, + _session: OpticalFlowSessionNV, + _p_execute_info: *const OpticalFlowExecuteInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_optical_flow_execute_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdOpticalFlowExecuteNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_optical_flow_execute_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl AccessFlags2 { + pub const OPTICAL_FLOW_READ_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_WRITE_NV: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl Format { + pub const R16G16_S10_5_NV: Self = Self(1_000_464_000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl FormatFeatureFlags2 { + pub const OPTICAL_FLOW_IMAGE_NV: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_VECTOR_NV: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_COST_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl ObjectType { + pub const OPTICAL_FLOW_SESSION_NV: Self = Self(1_000_464_000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl PipelineStageFlags2 { + pub const OPTICAL_FLOW_NV: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl QueueFlags { + pub const OPTICAL_FLOW_NV: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl StructureType { + pub const PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: Self = Self(1_000_464_000); + pub const PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: Self = Self(1_000_464_001); + pub const OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: Self = Self(1_000_464_002); + pub const OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: Self = Self(1_000_464_003); + pub const OPTICAL_FLOW_SESSION_CREATE_INFO_NV: Self = Self(1_000_464_004); + pub const OPTICAL_FLOW_EXECUTE_INFO_NV: Self = Self(1_000_464_005); + pub const OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: Self = Self(1_000_464_010); +} +impl ExtLegacyDitheringFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_legacy_dithering\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtLegacyDitheringFn {} +unsafe impl Send for ExtLegacyDitheringFn {} +unsafe impl Sync for ExtLegacyDitheringFn {} +impl ExtLegacyDitheringFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_legacy_dithering'"] +impl RenderingFlags { + pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_legacy_dithering'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: Self = Self(1_000_465_000); +} +#[doc = "Generated from 'VK_EXT_legacy_dithering'"] +impl SubpassDescriptionFlags { + pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000_0000); +} +impl ExtPipelineProtectedAccessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_protected_access\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPipelineProtectedAccessFn {} +unsafe impl Send for ExtPipelineProtectedAccessFn {} +unsafe impl Sync for ExtPipelineProtectedAccessFn {} +impl ExtPipelineProtectedAccessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"] +impl PipelineCreateFlags { + pub const NO_PROTECTED_ACCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); + pub const PROTECTED_ACCESS_ONLY_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: Self = Self(1_000_466_000); +} +impl ExtExtension468Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_468\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension468Fn {} +unsafe impl Send for ExtExtension468Fn {} +unsafe impl Sync for ExtExtension468Fn {} +impl ExtExtension468Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AndroidExtension469Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_extension_469\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AndroidExtension469Fn {} +unsafe impl Send for AndroidExtension469Fn {} +unsafe impl Sync for AndroidExtension469Fn {} +impl AndroidExtension469Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension470Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_470\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension470Fn {} +unsafe impl Send for AmdExtension470Fn {} +unsafe impl Sync for AmdExtension470Fn {} +impl AmdExtension470Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension471Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_471\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension471Fn {} +unsafe impl Send for AmdExtension471Fn {} +unsafe impl Sync for AmdExtension471Fn {} +impl AmdExtension471Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension472Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_472\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension472Fn {} +unsafe impl Send for AmdExtension472Fn {} +unsafe impl Sync for AmdExtension472Fn {} +impl AmdExtension472Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension473Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_473\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension473Fn {} +unsafe impl Send for AmdExtension473Fn {} +unsafe impl Sync for AmdExtension473Fn {} +impl AmdExtension473Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension474Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_474\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension474Fn {} +unsafe impl Send for AmdExtension474Fn {} +unsafe impl Sync for AmdExtension474Fn {} +impl AmdExtension474Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension475Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_475\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension475Fn {} +unsafe impl Send for AmdExtension475Fn {} +unsafe impl Sync for AmdExtension475Fn {} +impl AmdExtension475Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension476Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_476\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension476Fn {} +unsafe impl Send for AmdExtension476Fn {} +unsafe impl Sync for AmdExtension476Fn {} +impl AmdExtension476Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension477Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_477\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension477Fn {} +unsafe impl Send for AmdExtension477Fn {} +unsafe impl Sync for AmdExtension477Fn {} +impl AmdExtension477Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension478Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_478\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension478Fn {} +unsafe impl Send for AmdExtension478Fn {} +unsafe impl Sync for AmdExtension478Fn {} +impl AmdExtension478Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension479Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_479\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension479Fn {} +unsafe impl Send for AmdExtension479Fn {} +unsafe impl Sync for AmdExtension479Fn {} +impl AmdExtension479Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension480Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_480\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension480Fn {} +unsafe impl Send for ExtExtension480Fn {} +unsafe impl Sync for ExtExtension480Fn {} +impl ExtExtension480Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension481Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_481\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension481Fn {} +unsafe impl Send for ExtExtension481Fn {} +unsafe impl Sync for ExtExtension481Fn {} +impl ExtExtension481Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension482Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_482\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension482Fn {} +unsafe impl Send for ExtExtension482Fn {} +unsafe impl Sync for ExtExtension482Fn {} +impl ExtExtension482Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension483Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_483\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension483Fn {} +unsafe impl Send for ExtExtension483Fn {} +unsafe impl Sync for ExtExtension483Fn {} +impl ExtExtension483Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_483'"] +impl ShaderStageFlags { + pub const EXT_483_RESERVE_15: Self = Self(0b1000_0000_0000_0000); + pub const EXT_483_RESERVE_16: Self = Self(0b1_0000_0000_0000_0000); + pub const EXT_483_RESERVE_17: Self = Self(0b10_0000_0000_0000_0000); +} +impl ExtExtension484Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_484\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension484Fn {} +unsafe impl Send for ExtExtension484Fn {} +unsafe impl Sync for ExtExtension484Fn {} +impl ExtExtension484Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomTilePropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_tile_properties\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetFramebufferTilePropertiesQCOM = unsafe extern "system" fn( + device: Device, + framebuffer: Framebuffer, + p_properties_count: *mut u32, + p_properties: *mut TilePropertiesQCOM, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDynamicRenderingTilePropertiesQCOM = unsafe extern "system" fn( + device: Device, + p_rendering_info: *const RenderingInfo, + p_properties: *mut TilePropertiesQCOM, +) -> Result; +#[derive(Clone)] +pub struct QcomTilePropertiesFn { + pub get_framebuffer_tile_properties_qcom: PFN_vkGetFramebufferTilePropertiesQCOM, + pub get_dynamic_rendering_tile_properties_qcom: PFN_vkGetDynamicRenderingTilePropertiesQCOM, +} +unsafe impl Send for QcomTilePropertiesFn {} +unsafe impl Sync for QcomTilePropertiesFn {} +impl QcomTilePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_framebuffer_tile_properties_qcom: unsafe { + unsafe extern "system" fn get_framebuffer_tile_properties_qcom( + _device: Device, + _framebuffer: Framebuffer, + _p_properties_count: *mut u32, + _p_properties: *mut TilePropertiesQCOM, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_framebuffer_tile_properties_qcom) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetFramebufferTilePropertiesQCOM\0", + ); + let val = _f(cname); + if val.is_null() { + get_framebuffer_tile_properties_qcom + } else { + ::std::mem::transmute(val) + } + }, + get_dynamic_rendering_tile_properties_qcom: unsafe { + unsafe extern "system" fn get_dynamic_rendering_tile_properties_qcom( + _device: Device, + _p_rendering_info: *const RenderingInfo, + _p_properties: *mut TilePropertiesQCOM, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_dynamic_rendering_tile_properties_qcom) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDynamicRenderingTilePropertiesQCOM\0", + ); + let val = _f(cname); + if val.is_null() { + get_dynamic_rendering_tile_properties_qcom + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_QCOM_tile_properties'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: Self = Self(1_000_484_000); + pub const TILE_PROPERTIES_QCOM: Self = Self(1_000_484_001); +} +impl SecAmigoProfilingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_amigo_profiling\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct SecAmigoProfilingFn {} +unsafe impl Send for SecAmigoProfilingFn {} +unsafe impl Sync for SecAmigoProfilingFn {} +impl SecAmigoProfilingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_SEC_amigo_profiling'"] +impl StructureType { + pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: Self = Self(1_000_485_000); + pub const AMIGO_PROFILING_SUBMIT_INFO_SEC: Self = Self(1_000_485_001); +} +impl ExtExtension487Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_487\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension487Fn {} +unsafe impl Send for ExtExtension487Fn {} +unsafe impl Sync for ExtExtension487Fn {} +impl ExtExtension487Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension488Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_488\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension488Fn {} +unsafe impl Send for ExtExtension488Fn {} +unsafe impl Sync for ExtExtension488Fn {} +impl ExtExtension488Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomMultiviewPerViewViewportsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_QCOM_multiview_per_view_viewports\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomMultiviewPerViewViewportsFn {} +unsafe impl Send for QcomMultiviewPerViewViewportsFn {} +unsafe impl Sync for QcomMultiviewPerViewViewportsFn {} +impl QcomMultiviewPerViewViewportsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_multiview_per_view_viewports'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: Self = + Self(1_000_488_000); +} +impl NvExtension490Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_490\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension490Fn {} +unsafe impl Send for NvExtension490Fn {} +unsafe impl Sync for NvExtension490Fn {} +impl NvExtension490Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvRayTracingInvocationReorderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_ray_tracing_invocation_reorder\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvRayTracingInvocationReorderFn {} +unsafe impl Send for NvRayTracingInvocationReorderFn {} +unsafe impl Sync for NvRayTracingInvocationReorderFn {} +impl NvRayTracingInvocationReorderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_ray_tracing_invocation_reorder'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: Self = + Self(1_000_490_000); + pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: Self = + Self(1_000_490_001); +} +impl NvExtension492Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_492\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension492Fn {} +unsafe impl Send for NvExtension492Fn {} +unsafe impl Sync for NvExtension492Fn {} +impl NvExtension492Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension493Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_493\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension493Fn {} +unsafe impl Send for NvExtension493Fn {} +unsafe impl Sync for NvExtension493Fn {} +impl NvExtension493Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension494Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_494\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension494Fn {} +unsafe impl Send for NvExtension494Fn {} +unsafe impl Sync for NvExtension494Fn {} +impl NvExtension494Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMutableDescriptorTypeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mutable_descriptor_type\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtMutableDescriptorTypeFn {} +unsafe impl Send for ExtMutableDescriptorTypeFn {} +unsafe impl Sync for ExtMutableDescriptorTypeFn {} +impl ExtMutableDescriptorTypeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"] +impl DescriptorPoolCreateFlags { + pub const HOST_ONLY_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"] +impl DescriptorSetLayoutCreateFlags { + pub const HOST_ONLY_POOL_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"] +impl DescriptorType { + pub const MUTABLE_EXT: Self = Self(1_000_351_000); +} +#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: Self = Self(1_000_351_000); + pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: Self = Self(1_000_351_002); +} +impl ExtExtension496Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_496\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension496Fn {} +unsafe impl Send for ExtExtension496Fn {} +unsafe impl Sync for ExtExtension496Fn {} +impl ExtExtension496Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension497Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_497\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension497Fn {} +unsafe impl Send for ExtExtension497Fn {} +unsafe impl Sync for ExtExtension497Fn {} +impl ExtExtension497Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmShaderCoreBuiltinsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_shader_core_builtins\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ArmShaderCoreBuiltinsFn {} +unsafe impl Send for ArmShaderCoreBuiltinsFn {} +unsafe impl Sync for ArmShaderCoreBuiltinsFn {} +impl ArmShaderCoreBuiltinsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_ARM_shader_core_builtins'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: Self = Self(1_000_497_000); + pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: Self = Self(1_000_497_001); +} +impl ExtExtension499Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_499\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension499Fn {} +unsafe impl Send for ExtExtension499Fn {} +unsafe impl Sync for ExtExtension499Fn {} +impl ExtExtension499Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension500Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_500\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension500Fn {} +unsafe impl Send for ExtExtension500Fn {} +unsafe impl Sync for ExtExtension500Fn {} +impl ExtExtension500Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension501Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_501\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension501Fn {} +unsafe impl Send for ExtExtension501Fn {} +unsafe impl Sync for ExtExtension501Fn {} +impl ExtExtension501Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension502Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_502\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension502Fn {} +unsafe impl Send for ExtExtension502Fn {} +unsafe impl Sync for ExtExtension502Fn {} +impl ExtExtension502Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension503Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_503\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension503Fn {} +unsafe impl Send for ExtExtension503Fn {} +unsafe impl Sync for ExtExtension503Fn {} +impl ExtExtension503Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension504Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_504\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension504Fn {} +unsafe impl Send for NvExtension504Fn {} +unsafe impl Sync for NvExtension504Fn {} +impl NvExtension504Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension505Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_505\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension505Fn {} +unsafe impl Send for ExtExtension505Fn {} +unsafe impl Sync for ExtExtension505Fn {} +impl ExtExtension505Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension506Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_506\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension506Fn {} +unsafe impl Send for NvExtension506Fn {} +unsafe impl Sync for NvExtension506Fn {} +impl NvExtension506Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} diff --git a/third_party/rust/ash/src/vk/feature_extensions.rs b/third_party/rust/ash/src/vk/feature_extensions.rs new file mode 100644 index 0000000000..4b1820c9a7 --- /dev/null +++ b/third_party/rust/ash/src/vk/feature_extensions.rs @@ -0,0 +1,451 @@ +use crate::vk::bitflags::*; +use crate::vk::enums::*; +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl BufferCreateFlags { + #[doc = "Buffer requires protected memory"] + pub const PROTECTED: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl CommandPoolCreateFlags { + #[doc = "Command buffers allocated from pool are protected command buffers"] + pub const PROTECTED: Self = Self(0b100); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl DependencyFlags { + #[doc = "Dependency is across devices"] + pub const DEVICE_GROUP: Self = Self(0b100); + pub const VIEW_LOCAL: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl DeviceQueueCreateFlags { + #[doc = "Queue is a protected-capable device queue"] + pub const PROTECTED: Self = Self(0b1); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl Format { + pub const G8B8G8R8_422_UNORM: Self = Self(1_000_156_000); + pub const B8G8R8G8_422_UNORM: Self = Self(1_000_156_001); + pub const G8_B8_R8_3PLANE_420_UNORM: Self = Self(1_000_156_002); + pub const G8_B8R8_2PLANE_420_UNORM: Self = Self(1_000_156_003); + pub const G8_B8_R8_3PLANE_422_UNORM: Self = Self(1_000_156_004); + pub const G8_B8R8_2PLANE_422_UNORM: Self = Self(1_000_156_005); + pub const G8_B8_R8_3PLANE_444_UNORM: Self = Self(1_000_156_006); + pub const R10X6_UNORM_PACK16: Self = Self(1_000_156_007); + pub const R10X6G10X6_UNORM_2PACK16: Self = Self(1_000_156_008); + pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Self(1_000_156_009); + pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Self(1_000_156_010); + pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Self(1_000_156_011); + pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_012); + pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_013); + pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_014); + pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_015); + pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Self(1_000_156_016); + pub const R12X4_UNORM_PACK16: Self = Self(1_000_156_017); + pub const R12X4G12X4_UNORM_2PACK16: Self = Self(1_000_156_018); + pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Self(1_000_156_019); + pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Self(1_000_156_020); + pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Self(1_000_156_021); + pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_022); + pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_023); + pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_024); + pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_025); + pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Self(1_000_156_026); + pub const G16B16G16R16_422_UNORM: Self = Self(1_000_156_027); + pub const B16G16R16G16_422_UNORM: Self = Self(1_000_156_028); + pub const G16_B16_R16_3PLANE_420_UNORM: Self = Self(1_000_156_029); + pub const G16_B16R16_2PLANE_420_UNORM: Self = Self(1_000_156_030); + pub const G16_B16_R16_3PLANE_422_UNORM: Self = Self(1_000_156_031); + pub const G16_B16R16_2PLANE_422_UNORM: Self = Self(1_000_156_032); + pub const G16_B16_R16_3PLANE_444_UNORM: Self = Self(1_000_156_033); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl FormatFeatureFlags { + #[doc = "Format can be used as the source image of image transfer commands"] + pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000); + #[doc = "Format can be used as the destination image of image transfer commands"] + pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000); + #[doc = "Format can have midpoint rather than cosited chroma samples"] + pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000); + #[doc = "Format can be used with linear filtering whilst color conversion is enabled"] + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000); + #[doc = "Format can have different chroma, min and mag filters"] + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = + Self(0b1000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = + Self(0b1_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = + Self(0b10_0000_0000_0000_0000_0000); + #[doc = "Format supports disjoint planes"] + pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000); + #[doc = "Format can have cosited rather than midpoint chroma samples"] + pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl ImageAspectFlags { + pub const PLANE_0: Self = Self(0b1_0000); + pub const PLANE_1: Self = Self(0b10_0000); + pub const PLANE_2: Self = Self(0b100_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl ImageCreateFlags { + pub const ALIAS: Self = Self(0b100_0000_0000); + #[doc = "Allows using VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions when binding memory to the image"] + pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b100_0000); + #[doc = "The 3D image can be viewed as a 2D or 2D array image"] + pub const TYPE_2D_ARRAY_COMPATIBLE: Self = Self(0b10_0000); + pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = Self(0b1000_0000); + pub const EXTENDED_USAGE: Self = Self(0b1_0000_0000); + #[doc = "Image requires protected memory"] + pub const PROTECTED: Self = Self(0b1000_0000_0000); + pub const DISJOINT: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl ImageLayout { + pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1_000_117_000); + pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = Self(1_000_117_001); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl MemoryHeapFlags { + #[doc = "If set, heap allocations allocate multiple instances by default"] + pub const MULTI_INSTANCE: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl MemoryPropertyFlags { + #[doc = "Memory is protected"] + pub const PROTECTED: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl ObjectType { + pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000); + pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl PipelineCreateFlags { + pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(0b1000); + pub const DISPATCH_BASE: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl QueueFlags { + #[doc = "Queues may support protected operations"] + pub const PROTECTED: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl Result { + pub const ERROR_OUT_OF_POOL_MEMORY: Self = Self(-1_000_069_000); + pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Self(-1_000_072_003); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = Self(1_000_094_000); + pub const BIND_BUFFER_MEMORY_INFO: Self = Self(1_000_157_000); + pub const BIND_IMAGE_MEMORY_INFO: Self = Self(1_000_157_001); + pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = Self(1_000_083_000); + pub const MEMORY_DEDICATED_REQUIREMENTS: Self = Self(1_000_127_000); + pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = Self(1_000_127_001); + pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = Self(1_000_060_000); + pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = Self(1_000_060_003); + pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = Self(1_000_060_004); + pub const DEVICE_GROUP_SUBMIT_INFO: Self = Self(1_000_060_005); + pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = Self(1_000_060_006); + pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = Self(1_000_060_013); + pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = Self(1_000_060_014); + pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = Self(1_000_070_000); + pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = Self(1_000_070_001); + pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_000); + pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_001); + pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_002); + pub const MEMORY_REQUIREMENTS_2: Self = Self(1_000_146_003); + pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = Self(1_000_146_004); + pub const PHYSICAL_DEVICE_FEATURES_2: Self = Self(1_000_059_000); + pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = Self(1_000_059_001); + pub const FORMAT_PROPERTIES_2: Self = Self(1_000_059_002); + pub const IMAGE_FORMAT_PROPERTIES_2: Self = Self(1_000_059_003); + pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = Self(1_000_059_004); + pub const QUEUE_FAMILY_PROPERTIES_2: Self = Self(1_000_059_005); + pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = Self(1_000_059_006); + pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = Self(1_000_059_007); + pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = Self(1_000_059_008); + pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = Self(1_000_117_000); + pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = Self(1_000_117_001); + pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = Self(1_000_117_002); + pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = Self(1_000_117_003); + pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = Self(1_000_053_000); + pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = Self(1_000_053_001); + pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = Self(1_000_053_002); + pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = Self(1_000_120_000); + pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self = + Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + pub const PROTECTED_SUBMIT_INFO: Self = Self(1_000_145_000); + pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = Self(1_000_145_001); + pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = Self(1_000_145_002); + pub const DEVICE_QUEUE_INFO_2: Self = Self(1_000_145_003); + pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = Self(1_000_156_000); + pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = Self(1_000_156_001); + pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = Self(1_000_156_002); + pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = Self(1_000_156_003); + pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = Self(1_000_156_004); + pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = Self(1_000_156_005); + pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = Self(1_000_085_000); + pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = Self(1_000_071_000); + pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = Self(1_000_071_001); + pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = Self(1_000_071_002); + pub const EXTERNAL_BUFFER_PROPERTIES: Self = Self(1_000_071_003); + pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = Self(1_000_071_004); + pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = Self(1_000_072_000); + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = Self(1_000_072_001); + pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = Self(1_000_072_002); + pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = Self(1_000_112_000); + pub const EXTERNAL_FENCE_PROPERTIES: Self = Self(1_000_112_001); + pub const EXPORT_FENCE_CREATE_INFO: Self = Self(1_000_113_000); + pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = Self(1_000_077_000); + pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = Self(1_000_076_000); + pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = Self(1_000_076_001); + pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = Self(1_000_168_000); + pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = Self(1_000_168_001); + pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: Self = Self(1_000_063_000); + pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = + Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl BufferCreateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl BufferUsageFlags { + pub const SHADER_DEVICE_ADDRESS: Self = Self(0b10_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl DescriptorPoolCreateFlags { + pub const UPDATE_AFTER_BIND: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl DescriptorSetLayoutCreateFlags { + pub const UPDATE_AFTER_BIND_POOL: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl FormatFeatureFlags { + #[doc = "Format can be used with min/max reduction filtering"] + pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl FramebufferCreateFlags { + pub const IMAGELESS: Self = Self(0b1); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl ImageLayout { + pub const DEPTH_ATTACHMENT_OPTIMAL: Self = Self(1_000_241_000); + pub const DEPTH_READ_ONLY_OPTIMAL: Self = Self(1_000_241_001); + pub const STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1_000_241_002); + pub const STENCIL_READ_ONLY_OPTIMAL: Self = Self(1_000_241_003); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl MemoryAllocateFlags { + pub const DEVICE_ADDRESS: Self = Self(0b10); + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b100); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl Result { + pub const ERROR_FRAGMENTATION: Self = Self(-1_000_161_000); + pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Self(-1_000_257_000); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = Self(49); + pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = Self(50); + pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = Self(51); + pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = Self(52); + pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = Self(1_000_147_000); + pub const ATTACHMENT_DESCRIPTION_2: Self = Self(1_000_109_000); + pub const ATTACHMENT_REFERENCE_2: Self = Self(1_000_109_001); + pub const SUBPASS_DESCRIPTION_2: Self = Self(1_000_109_002); + pub const SUBPASS_DEPENDENCY_2: Self = Self(1_000_109_003); + pub const RENDER_PASS_CREATE_INFO_2: Self = Self(1_000_109_004); + pub const SUBPASS_BEGIN_INFO: Self = Self(1_000_109_005); + pub const SUBPASS_END_INFO: Self = Self(1_000_109_006); + pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: Self = Self(1_000_177_000); + pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES: Self = Self(1_000_196_000); + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: Self = Self(1_000_180_000); + pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: Self = Self(1_000_082_000); + pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: Self = Self(1_000_197_000); + pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: Self = Self(1_000_161_000); + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: Self = Self(1_000_161_001); + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: Self = Self(1_000_161_002); + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: Self = Self(1_000_161_003); + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: Self = Self(1_000_161_004); + pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: Self = Self(1_000_199_000); + pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: Self = Self(1_000_199_001); + pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: Self = Self(1_000_221_000); + pub const IMAGE_STENCIL_USAGE_CREATE_INFO: Self = Self(1_000_246_000); + pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: Self = Self(1_000_130_000); + pub const SAMPLER_REDUCTION_MODE_CREATE_INFO: Self = Self(1_000_130_001); + pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: Self = Self(1_000_211_000); + pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: Self = Self(1_000_108_000); + pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: Self = Self(1_000_108_001); + pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: Self = Self(1_000_108_002); + pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO: Self = Self(1_000_108_003); + pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: Self = Self(1_000_253_000); + pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: Self = Self(1_000_175_000); + pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: Self = Self(1_000_241_000); + pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT: Self = Self(1_000_241_001); + pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: Self = Self(1_000_241_002); + pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: Self = Self(1_000_261_000); + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: Self = Self(1_000_207_000); + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: Self = Self(1_000_207_001); + pub const SEMAPHORE_TYPE_CREATE_INFO: Self = Self(1_000_207_002); + pub const TIMELINE_SEMAPHORE_SUBMIT_INFO: Self = Self(1_000_207_003); + pub const SEMAPHORE_WAIT_INFO: Self = Self(1_000_207_004); + pub const SEMAPHORE_SIGNAL_INFO: Self = Self(1_000_207_005); + pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: Self = Self(1_000_257_000); + pub const BUFFER_DEVICE_ADDRESS_INFO: Self = Self(1_000_244_001); + pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: Self = Self(1_000_257_002); + pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: Self = Self(1_000_257_003); + pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: Self = Self(1_000_257_004); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl AccessFlags { + pub const NONE: Self = Self(0); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl AttachmentStoreOp { + pub const NONE: Self = Self(1_000_301_000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl DescriptorType { + pub const INLINE_UNIFORM_BLOCK: Self = Self(1_000_138_000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl DynamicState { + pub const CULL_MODE: Self = Self(1_000_267_000); + pub const FRONT_FACE: Self = Self(1_000_267_001); + pub const PRIMITIVE_TOPOLOGY: Self = Self(1_000_267_002); + pub const VIEWPORT_WITH_COUNT: Self = Self(1_000_267_003); + pub const SCISSOR_WITH_COUNT: Self = Self(1_000_267_004); + pub const VERTEX_INPUT_BINDING_STRIDE: Self = Self(1_000_267_005); + pub const DEPTH_TEST_ENABLE: Self = Self(1_000_267_006); + pub const DEPTH_WRITE_ENABLE: Self = Self(1_000_267_007); + pub const DEPTH_COMPARE_OP: Self = Self(1_000_267_008); + pub const DEPTH_BOUNDS_TEST_ENABLE: Self = Self(1_000_267_009); + pub const STENCIL_TEST_ENABLE: Self = Self(1_000_267_010); + pub const STENCIL_OP: Self = Self(1_000_267_011); + pub const RASTERIZER_DISCARD_ENABLE: Self = Self(1_000_377_001); + pub const DEPTH_BIAS_ENABLE: Self = Self(1_000_377_002); + pub const PRIMITIVE_RESTART_ENABLE: Self = Self(1_000_377_004); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl EventCreateFlags { + pub const DEVICE_ONLY: Self = Self(0b1); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl Format { + pub const G8_B8R8_2PLANE_444_UNORM: Self = Self(1_000_330_000); + pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: Self = Self(1_000_330_001); + pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: Self = Self(1_000_330_002); + pub const G16_B16R16_2PLANE_444_UNORM: Self = Self(1_000_330_003); + pub const A4R4G4B4_UNORM_PACK16: Self = Self(1_000_340_000); + pub const A4B4G4R4_UNORM_PACK16: Self = Self(1_000_340_001); + pub const ASTC_4X4_SFLOAT_BLOCK: Self = Self(1_000_066_000); + pub const ASTC_5X4_SFLOAT_BLOCK: Self = Self(1_000_066_001); + pub const ASTC_5X5_SFLOAT_BLOCK: Self = Self(1_000_066_002); + pub const ASTC_6X5_SFLOAT_BLOCK: Self = Self(1_000_066_003); + pub const ASTC_6X6_SFLOAT_BLOCK: Self = Self(1_000_066_004); + pub const ASTC_8X5_SFLOAT_BLOCK: Self = Self(1_000_066_005); + pub const ASTC_8X6_SFLOAT_BLOCK: Self = Self(1_000_066_006); + pub const ASTC_8X8_SFLOAT_BLOCK: Self = Self(1_000_066_007); + pub const ASTC_10X5_SFLOAT_BLOCK: Self = Self(1_000_066_008); + pub const ASTC_10X6_SFLOAT_BLOCK: Self = Self(1_000_066_009); + pub const ASTC_10X8_SFLOAT_BLOCK: Self = Self(1_000_066_010); + pub const ASTC_10X10_SFLOAT_BLOCK: Self = Self(1_000_066_011); + pub const ASTC_12X10_SFLOAT_BLOCK: Self = Self(1_000_066_012); + pub const ASTC_12X12_SFLOAT_BLOCK: Self = Self(1_000_066_013); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl ImageAspectFlags { + pub const NONE: Self = Self(0); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl ImageLayout { + pub const READ_ONLY_OPTIMAL: Self = Self(1_000_314_000); + pub const ATTACHMENT_OPTIMAL: Self = Self(1_000_314_001); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl ObjectType { + pub const PRIVATE_DATA_SLOT: Self = Self(1_000_295_000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl PipelineCacheCreateFlags { + pub const EXTERNALLY_SYNCHRONIZED: Self = Self(0b1); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl PipelineCreateFlags { + pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(0b1_0000_0000); + pub const EARLY_RETURN_ON_FAILURE: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl PipelineShaderStageCreateFlags { + pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(0b1); + pub const REQUIRE_FULL_SUBGROUPS: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl PipelineStageFlags { + pub const NONE: Self = Self(0); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl Result { + pub const PIPELINE_COMPILE_REQUIRED: Self = Self(1_000_297_000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: Self = Self(53); + pub const PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: Self = Self(54); + pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO: Self = Self(1_000_192_000); + pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: Self = Self(1_000_215_000); + pub const PHYSICAL_DEVICE_TOOL_PROPERTIES: Self = Self(1_000_245_000); + pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: Self = + Self(1_000_276_000); + pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: Self = Self(1_000_295_000); + pub const DEVICE_PRIVATE_DATA_CREATE_INFO: Self = Self(1_000_295_001); + pub const PRIVATE_DATA_SLOT_CREATE_INFO: Self = Self(1_000_295_002); + pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: Self = Self(1_000_297_000); + pub const MEMORY_BARRIER_2: Self = Self(1_000_314_000); + pub const BUFFER_MEMORY_BARRIER_2: Self = Self(1_000_314_001); + pub const IMAGE_MEMORY_BARRIER_2: Self = Self(1_000_314_002); + pub const DEPENDENCY_INFO: Self = Self(1_000_314_003); + pub const SUBMIT_INFO_2: Self = Self(1_000_314_004); + pub const SEMAPHORE_SUBMIT_INFO: Self = Self(1_000_314_005); + pub const COMMAND_BUFFER_SUBMIT_INFO: Self = Self(1_000_314_006); + pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: Self = Self(1_000_314_007); + pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: Self = Self(1_000_325_000); + pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: Self = Self(1_000_335_000); + pub const COPY_BUFFER_INFO_2: Self = Self(1_000_337_000); + pub const COPY_IMAGE_INFO_2: Self = Self(1_000_337_001); + pub const COPY_BUFFER_TO_IMAGE_INFO_2: Self = Self(1_000_337_002); + pub const COPY_IMAGE_TO_BUFFER_INFO_2: Self = Self(1_000_337_003); + pub const BLIT_IMAGE_INFO_2: Self = Self(1_000_337_004); + pub const RESOLVE_IMAGE_INFO_2: Self = Self(1_000_337_005); + pub const BUFFER_COPY_2: Self = Self(1_000_337_006); + pub const IMAGE_COPY_2: Self = Self(1_000_337_007); + pub const IMAGE_BLIT_2: Self = Self(1_000_337_008); + pub const BUFFER_IMAGE_COPY_2: Self = Self(1_000_337_009); + pub const IMAGE_RESOLVE_2: Self = Self(1_000_337_010); + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: Self = Self(1_000_225_000); + pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: Self = Self(1_000_225_001); + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: Self = Self(1_000_225_002); + pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: Self = Self(1_000_138_000); + pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: Self = Self(1_000_138_001); + pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: Self = Self(1_000_138_002); + pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: Self = Self(1_000_138_003); + pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: Self = Self(1_000_066_000); + pub const RENDERING_INFO: Self = Self(1_000_044_000); + pub const RENDERING_ATTACHMENT_INFO: Self = Self(1_000_044_001); + pub const PIPELINE_RENDERING_CREATE_INFO: Self = Self(1_000_044_002); + pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: Self = Self(1_000_044_003); + pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: Self = Self(1_000_044_004); + pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: Self = Self(1_000_280_000); + pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: Self = Self(1_000_280_001); + pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: Self = Self(1_000_281_001); + pub const FORMAT_PROPERTIES_3: Self = Self(1_000_360_000); + pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: Self = Self(1_000_413_000); + pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: Self = Self(1_000_413_001); + pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS: Self = Self(1_000_413_002); + pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS: Self = Self(1_000_413_003); +} diff --git a/third_party/rust/ash/src/vk/features.rs b/third_party/rust/ash/src/vk/features.rs new file mode 100644 index 0000000000..4a52e377ef --- /dev/null +++ b/third_party/rust/ash/src/vk/features.rs @@ -0,0 +1,5353 @@ +use crate::vk::bitflags::*; +use crate::vk::definitions::*; +use crate::vk::enums::*; +use std::os::raw::*; +#[allow(non_camel_case_types)] +pub type PFN_vkGetInstanceProcAddr = + unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction; +#[derive(Clone)] +pub struct StaticFn { + pub get_instance_proc_addr: PFN_vkGetInstanceProcAddr, +} +unsafe impl Send for StaticFn {} +unsafe impl Sync for StaticFn {} +impl StaticFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_instance_proc_addr: unsafe { + unsafe extern "system" fn get_instance_proc_addr( + _instance: Instance, + _p_name: *const c_char, + ) -> PFN_vkVoidFunction { + panic!(concat!( + "Unable to load ", + stringify!(get_instance_proc_addr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetInstanceProcAddr\0"); + let val = _f(cname); + if val.is_null() { + get_instance_proc_addr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateInstance = unsafe extern "system" fn( + p_create_info: *const InstanceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_instance: *mut Instance, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn( + p_layer_name: *const c_char, + p_property_count: *mut u32, + p_properties: *mut ExtensionProperties, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn( + p_property_count: *mut u32, + p_properties: *mut LayerProperties, +) -> Result; +#[derive(Clone)] +pub struct EntryFnV1_0 { + pub create_instance: PFN_vkCreateInstance, + pub enumerate_instance_extension_properties: PFN_vkEnumerateInstanceExtensionProperties, + pub enumerate_instance_layer_properties: PFN_vkEnumerateInstanceLayerProperties, +} +unsafe impl Send for EntryFnV1_0 {} +unsafe impl Sync for EntryFnV1_0 {} +impl EntryFnV1_0 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_instance: unsafe { + unsafe extern "system" fn create_instance( + _p_create_info: *const InstanceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_instance: *mut Instance, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_instance))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateInstance\0"); + let val = _f(cname); + if val.is_null() { + create_instance + } else { + ::std::mem::transmute(val) + } + }, + enumerate_instance_extension_properties: unsafe { + unsafe extern "system" fn enumerate_instance_extension_properties( + _p_layer_name: *const c_char, + _p_property_count: *mut u32, + _p_properties: *mut ExtensionProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_instance_extension_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateInstanceExtensionProperties\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_instance_extension_properties + } else { + ::std::mem::transmute(val) + } + }, + enumerate_instance_layer_properties: unsafe { + unsafe extern "system" fn enumerate_instance_layer_properties( + _p_property_count: *mut u32, + _p_properties: *mut LayerProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_instance_layer_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateInstanceLayerProperties\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_instance_layer_properties + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyInstance = + unsafe extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks); +#[allow(non_camel_case_types)] +pub type PFN_vkEnumeratePhysicalDevices = unsafe extern "system" fn( + instance: Instance, + p_physical_device_count: *mut u32, + p_physical_devices: *mut PhysicalDevice, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_features: *mut PhysicalDeviceFeatures, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + p_format_properties: *mut FormatProperties, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + p_image_format_properties: *mut ImageFormatProperties, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_properties: *mut PhysicalDeviceProperties, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_queue_family_property_count: *mut u32, + p_queue_family_properties: *mut QueueFamilyProperties, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_memory_properties: *mut PhysicalDeviceMemoryProperties, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceProcAddr = + unsafe extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDevice = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_create_info: *const DeviceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_device: *mut Device, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_layer_name: *const c_char, + p_property_count: *mut u32, + p_properties: *mut ExtensionProperties, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut LayerProperties, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + samples: SampleCountFlags, + usage: ImageUsageFlags, + tiling: ImageTiling, + p_property_count: *mut u32, + p_properties: *mut SparseImageFormatProperties, +); +#[derive(Clone)] +pub struct InstanceFnV1_0 { + pub destroy_instance: PFN_vkDestroyInstance, + pub enumerate_physical_devices: PFN_vkEnumeratePhysicalDevices, + pub get_physical_device_features: PFN_vkGetPhysicalDeviceFeatures, + pub get_physical_device_format_properties: PFN_vkGetPhysicalDeviceFormatProperties, + pub get_physical_device_image_format_properties: PFN_vkGetPhysicalDeviceImageFormatProperties, + pub get_physical_device_properties: PFN_vkGetPhysicalDeviceProperties, + pub get_physical_device_queue_family_properties: PFN_vkGetPhysicalDeviceQueueFamilyProperties, + pub get_physical_device_memory_properties: PFN_vkGetPhysicalDeviceMemoryProperties, + pub get_device_proc_addr: PFN_vkGetDeviceProcAddr, + pub create_device: PFN_vkCreateDevice, + pub enumerate_device_extension_properties: PFN_vkEnumerateDeviceExtensionProperties, + pub enumerate_device_layer_properties: PFN_vkEnumerateDeviceLayerProperties, + pub get_physical_device_sparse_image_format_properties: + PFN_vkGetPhysicalDeviceSparseImageFormatProperties, +} +unsafe impl Send for InstanceFnV1_0 {} +unsafe impl Sync for InstanceFnV1_0 {} +impl InstanceFnV1_0 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + destroy_instance: unsafe { + unsafe extern "system" fn destroy_instance( + _instance: Instance, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_instance))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyInstance\0"); + let val = _f(cname); + if val.is_null() { + destroy_instance + } else { + ::std::mem::transmute(val) + } + }, + enumerate_physical_devices: unsafe { + unsafe extern "system" fn enumerate_physical_devices( + _instance: Instance, + _p_physical_device_count: *mut u32, + _p_physical_devices: *mut PhysicalDevice, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_physical_devices) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumeratePhysicalDevices\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_physical_devices + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_features: unsafe { + unsafe extern "system" fn get_physical_device_features( + _physical_device: PhysicalDevice, + _p_features: *mut PhysicalDeviceFeatures, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_features) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFeatures\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_features + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_format_properties: unsafe { + unsafe extern "system" fn get_physical_device_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _p_format_properties: *mut FormatProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_format_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFormatProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_format_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_image_format_properties: unsafe { + unsafe extern "system" fn get_physical_device_image_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _tiling: ImageTiling, + _usage: ImageUsageFlags, + _flags: ImageCreateFlags, + _p_image_format_properties: *mut ImageFormatProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_image_format_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceImageFormatProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_image_format_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_properties: unsafe { + unsafe extern "system" fn get_physical_device_properties( + _physical_device: PhysicalDevice, + _p_properties: *mut PhysicalDeviceProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_queue_family_properties: unsafe { + unsafe extern "system" fn get_physical_device_queue_family_properties( + _physical_device: PhysicalDevice, + _p_queue_family_property_count: *mut u32, + _p_queue_family_properties: *mut QueueFamilyProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_queue_family_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceQueueFamilyProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_queue_family_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_memory_properties: unsafe { + unsafe extern "system" fn get_physical_device_memory_properties( + _physical_device: PhysicalDevice, + _p_memory_properties: *mut PhysicalDeviceMemoryProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_memory_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceMemoryProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_memory_properties + } else { + ::std::mem::transmute(val) + } + }, + get_device_proc_addr: unsafe { + unsafe extern "system" fn get_device_proc_addr( + _device: Device, + _p_name: *const c_char, + ) -> PFN_vkVoidFunction { + panic!(concat!("Unable to load ", stringify!(get_device_proc_addr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceProcAddr\0"); + let val = _f(cname); + if val.is_null() { + get_device_proc_addr + } else { + ::std::mem::transmute(val) + } + }, + create_device: unsafe { + unsafe extern "system" fn create_device( + _physical_device: PhysicalDevice, + _p_create_info: *const DeviceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_device: *mut Device, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_device))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDevice\0"); + let val = _f(cname); + if val.is_null() { + create_device + } else { + ::std::mem::transmute(val) + } + }, + enumerate_device_extension_properties: unsafe { + unsafe extern "system" fn enumerate_device_extension_properties( + _physical_device: PhysicalDevice, + _p_layer_name: *const c_char, + _p_property_count: *mut u32, + _p_properties: *mut ExtensionProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_device_extension_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateDeviceExtensionProperties\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_device_extension_properties + } else { + ::std::mem::transmute(val) + } + }, + enumerate_device_layer_properties: unsafe { + unsafe extern "system" fn enumerate_device_layer_properties( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut LayerProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_device_layer_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateDeviceLayerProperties\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_device_layer_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_sparse_image_format_properties: unsafe { + unsafe extern "system" fn get_physical_device_sparse_image_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _samples: SampleCountFlags, + _usage: ImageUsageFlags, + _tiling: ImageTiling, + _p_property_count: *mut u32, + _p_properties: *mut SparseImageFormatProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_sparse_image_format_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSparseImageFormatProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_sparse_image_format_properties + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDevice = + unsafe extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceQueue = unsafe extern "system" fn( + device: Device, + queue_family_index: u32, + queue_index: u32, + p_queue: *mut Queue, +); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSubmit = unsafe extern "system" fn( + queue: Queue, + submit_count: u32, + p_submits: *const SubmitInfo, + fence: Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueWaitIdle = unsafe extern "system" fn(queue: Queue) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDeviceWaitIdle = unsafe extern "system" fn(device: Device) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAllocateMemory = unsafe extern "system" fn( + device: Device, + p_allocate_info: *const MemoryAllocateInfo, + p_allocator: *const AllocationCallbacks, + p_memory: *mut DeviceMemory, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkFreeMemory = unsafe extern "system" fn( + device: Device, + memory: DeviceMemory, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkMapMemory = unsafe extern "system" fn( + device: Device, + memory: DeviceMemory, + offset: DeviceSize, + size: DeviceSize, + flags: MemoryMapFlags, + pp_data: *mut *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUnmapMemory = unsafe extern "system" fn(device: Device, memory: DeviceMemory); +#[allow(non_camel_case_types)] +pub type PFN_vkFlushMappedMemoryRanges = unsafe extern "system" fn( + device: Device, + memory_range_count: u32, + p_memory_ranges: *const MappedMemoryRange, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn( + device: Device, + memory_range_count: u32, + p_memory_ranges: *const MappedMemoryRange, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn( + device: Device, + memory: DeviceMemory, + p_committed_memory_in_bytes: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBindBufferMemory = unsafe extern "system" fn( + device: Device, + buffer: Buffer, + memory: DeviceMemory, + memory_offset: DeviceSize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkBindImageMemory = unsafe extern "system" fn( + device: Device, + image: Image, + memory: DeviceMemory, + memory_offset: DeviceSize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferMemoryRequirements = unsafe extern "system" fn( + device: Device, + buffer: Buffer, + p_memory_requirements: *mut MemoryRequirements, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageMemoryRequirements = unsafe extern "system" fn( + device: Device, + image: Image, + p_memory_requirements: *mut MemoryRequirements, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn( + device: Device, + image: Image, + p_sparse_memory_requirement_count: *mut u32, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, +); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueBindSparse = unsafe extern "system" fn( + queue: Queue, + bind_info_count: u32, + p_bind_info: *const BindSparseInfo, + fence: Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateFence = unsafe extern "system" fn( + device: Device, + p_create_info: *const FenceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyFence = unsafe extern "system" fn( + device: Device, + fence: Fence, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkResetFences = + unsafe extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetFenceStatus = unsafe extern "system" fn(device: Device, fence: Fence) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWaitForFences = unsafe extern "system" fn( + device: Device, + fence_count: u32, + p_fences: *const Fence, + wait_all: Bool32, + timeout: u64, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSemaphore = unsafe extern "system" fn( + device: Device, + p_create_info: *const SemaphoreCreateInfo, + p_allocator: *const AllocationCallbacks, + p_semaphore: *mut Semaphore, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySemaphore = unsafe extern "system" fn( + device: Device, + semaphore: Semaphore, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateEvent = unsafe extern "system" fn( + device: Device, + p_create_info: *const EventCreateInfo, + p_allocator: *const AllocationCallbacks, + p_event: *mut Event, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyEvent = unsafe extern "system" fn( + device: Device, + event: Event, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetEventStatus = unsafe extern "system" fn(device: Device, event: Event) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetEvent = unsafe extern "system" fn(device: Device, event: Event) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkResetEvent = unsafe extern "system" fn(device: Device, event: Event) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateQueryPool = unsafe extern "system" fn( + device: Device, + p_create_info: *const QueryPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_query_pool: *mut QueryPool, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyQueryPool = unsafe extern "system" fn( + device: Device, + query_pool: QueryPool, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetQueryPoolResults = unsafe extern "system" fn( + device: Device, + query_pool: QueryPool, + first_query: u32, + query_count: u32, + data_size: usize, + p_data: *mut c_void, + stride: DeviceSize, + flags: QueryResultFlags, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateBuffer = unsafe extern "system" fn( + device: Device, + p_create_info: *const BufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_buffer: *mut Buffer, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyBuffer = unsafe extern "system" fn( + device: Device, + buffer: Buffer, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateBufferView = unsafe extern "system" fn( + device: Device, + p_create_info: *const BufferViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *mut BufferView, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyBufferView = unsafe extern "system" fn( + device: Device, + buffer_view: BufferView, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateImage = unsafe extern "system" fn( + device: Device, + p_create_info: *const ImageCreateInfo, + p_allocator: *const AllocationCallbacks, + p_image: *mut Image, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyImage = unsafe extern "system" fn( + device: Device, + image: Image, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSubresourceLayout = unsafe extern "system" fn( + device: Device, + image: Image, + p_subresource: *const ImageSubresource, + p_layout: *mut SubresourceLayout, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateImageView = unsafe extern "system" fn( + device: Device, + p_create_info: *const ImageViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *mut ImageView, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyImageView = unsafe extern "system" fn( + device: Device, + image_view: ImageView, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateShaderModule = unsafe extern "system" fn( + device: Device, + p_create_info: *const ShaderModuleCreateInfo, + p_allocator: *const AllocationCallbacks, + p_shader_module: *mut ShaderModule, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyShaderModule = unsafe extern "system" fn( + device: Device, + shader_module: ShaderModule, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreatePipelineCache = unsafe extern "system" fn( + device: Device, + p_create_info: *const PipelineCacheCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_cache: *mut PipelineCache, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyPipelineCache = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineCacheData = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + p_data_size: *mut usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkMergePipelineCaches = unsafe extern "system" fn( + device: Device, + dst_cache: PipelineCache, + src_cache_count: u32, + p_src_caches: *const PipelineCache, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateGraphicsPipelines = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const GraphicsPipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateComputePipelines = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const ComputePipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyPipeline = unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreatePipelineLayout = unsafe extern "system" fn( + device: Device, + p_create_info: *const PipelineLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_layout: *mut PipelineLayout, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyPipelineLayout = unsafe extern "system" fn( + device: Device, + pipeline_layout: PipelineLayout, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSampler = unsafe extern "system" fn( + device: Device, + p_create_info: *const SamplerCreateInfo, + p_allocator: *const AllocationCallbacks, + p_sampler: *mut Sampler, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySampler = unsafe extern "system" fn( + device: Device, + sampler: Sampler, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDescriptorSetLayout = unsafe extern "system" fn( + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_set_layout: *mut DescriptorSetLayout, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn( + device: Device, + descriptor_set_layout: DescriptorSetLayout, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDescriptorPool = unsafe extern "system" fn( + device: Device, + p_create_info: *const DescriptorPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_pool: *mut DescriptorPool, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDescriptorPool = unsafe extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkResetDescriptorPool = unsafe extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + flags: DescriptorPoolResetFlags, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAllocateDescriptorSets = unsafe extern "system" fn( + device: Device, + p_allocate_info: *const DescriptorSetAllocateInfo, + p_descriptor_sets: *mut DescriptorSet, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkFreeDescriptorSets = unsafe extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + descriptor_set_count: u32, + p_descriptor_sets: *const DescriptorSet, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUpdateDescriptorSets = unsafe extern "system" fn( + device: Device, + descriptor_write_count: u32, + p_descriptor_writes: *const WriteDescriptorSet, + descriptor_copy_count: u32, + p_descriptor_copies: *const CopyDescriptorSet, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateFramebuffer = unsafe extern "system" fn( + device: Device, + p_create_info: *const FramebufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_framebuffer: *mut Framebuffer, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyFramebuffer = unsafe extern "system" fn( + device: Device, + framebuffer: Framebuffer, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRenderPass = unsafe extern "system" fn( + device: Device, + p_create_info: *const RenderPassCreateInfo, + p_allocator: *const AllocationCallbacks, + p_render_pass: *mut RenderPass, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyRenderPass = unsafe extern "system" fn( + device: Device, + render_pass: RenderPass, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetRenderAreaGranularity = unsafe extern "system" fn( + device: Device, + render_pass: RenderPass, + p_granularity: *mut Extent2D, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCommandPool = unsafe extern "system" fn( + device: Device, + p_create_info: *const CommandPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_command_pool: *mut CommandPool, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCommandPool = unsafe extern "system" fn( + device: Device, + command_pool: CommandPool, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkResetCommandPool = unsafe extern "system" fn( + device: Device, + command_pool: CommandPool, + flags: CommandPoolResetFlags, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAllocateCommandBuffers = unsafe extern "system" fn( + device: Device, + p_allocate_info: *const CommandBufferAllocateInfo, + p_command_buffers: *mut CommandBuffer, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkFreeCommandBuffers = unsafe extern "system" fn( + device: Device, + command_pool: CommandPool, + command_buffer_count: u32, + p_command_buffers: *const CommandBuffer, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBeginCommandBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_begin_info: *const CommandBufferBeginInfo, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEndCommandBuffer = + unsafe extern "system" fn(command_buffer: CommandBuffer) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkResetCommandBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + flags: CommandBufferResetFlags, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindPipeline = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewport = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_viewports: *const Viewport, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetScissor = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_scissor: u32, + scissor_count: u32, + p_scissors: *const Rect2D, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineWidth = + unsafe extern "system" fn(command_buffer: CommandBuffer, line_width: f32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBias = unsafe extern "system" fn( + command_buffer: CommandBuffer, + depth_bias_constant_factor: f32, + depth_bias_clamp: f32, + depth_bias_slope_factor: f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetBlendConstants = + unsafe extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4]); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBounds = unsafe extern "system" fn( + command_buffer: CommandBuffer, + min_depth_bounds: f32, + max_depth_bounds: f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilCompareMask = unsafe extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + compare_mask: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilWriteMask = unsafe extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + write_mask: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilReference = unsafe extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + reference: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorSets = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: u32, + descriptor_set_count: u32, + p_descriptor_sets: *const DescriptorSet, + dynamic_offset_count: u32, + p_dynamic_offsets: *const u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindIndexBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + index_type: IndexType, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindVertexBuffers = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_binding: u32, + binding_count: u32, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDraw = unsafe extern "system" fn( + command_buffer: CommandBuffer, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndexed = unsafe extern "system" fn( + command_buffer: CommandBuffer, + index_count: u32, + instance_count: u32, + first_index: u32, + vertex_offset: i32, + first_instance: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndirect = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatch = unsafe extern "system" fn( + command_buffer: CommandBuffer, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatchIndirect = + unsafe extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_buffer: Buffer, + region_count: u32, + p_regions: *const BufferCopy, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: u32, + p_regions: *const ImageCopy, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBlitImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: u32, + p_regions: *const ImageBlit, + filter: Filter, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBufferToImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: u32, + p_regions: *const BufferImageCopy, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImageToBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_buffer: Buffer, + region_count: u32, + p_regions: *const BufferImageCopy, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdUpdateBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + data_size: DeviceSize, + p_data: *const c_void, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdFillBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + size: DeviceSize, + data: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdClearColorImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_color: *const ClearColorValue, + range_count: u32, + p_ranges: *const ImageSubresourceRange, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdClearDepthStencilImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_depth_stencil: *const ClearDepthStencilValue, + range_count: u32, + p_ranges: *const ImageSubresourceRange, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdClearAttachments = unsafe extern "system" fn( + command_buffer: CommandBuffer, + attachment_count: u32, + p_attachments: *const ClearAttachment, + rect_count: u32, + p_rects: *const ClearRect, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResolveImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: u32, + p_regions: *const ImageResolve, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetEvent = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResetEvent = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWaitEvents = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event_count: u32, + p_events: *const Event, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + memory_barrier_count: u32, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: u32, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: u32, + p_image_memory_barriers: *const ImageMemoryBarrier, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPipelineBarrier = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + dependency_flags: DependencyFlags, + memory_barrier_count: u32, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: u32, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: u32, + p_image_memory_barriers: *const ImageMemoryBarrier, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginQuery = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: u32, + flags: QueryControlFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndQuery = + unsafe extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResetQueryPool = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: u32, + query_count: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteTimestamp = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + query_pool: QueryPool, + query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: u32, + query_count: u32, + dst_buffer: Buffer, + dst_offset: DeviceSize, + stride: DeviceSize, + flags: QueryResultFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPushConstants = unsafe extern "system" fn( + command_buffer: CommandBuffer, + layout: PipelineLayout, + stage_flags: ShaderStageFlags, + offset: u32, + size: u32, + p_values: *const c_void, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginRenderPass = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_render_pass_begin: *const RenderPassBeginInfo, + contents: SubpassContents, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdNextSubpass = + unsafe extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndRenderPass = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdExecuteCommands = unsafe extern "system" fn( + command_buffer: CommandBuffer, + command_buffer_count: u32, + p_command_buffers: *const CommandBuffer, +); +#[derive(Clone)] +pub struct DeviceFnV1_0 { + pub destroy_device: PFN_vkDestroyDevice, + pub get_device_queue: PFN_vkGetDeviceQueue, + pub queue_submit: PFN_vkQueueSubmit, + pub queue_wait_idle: PFN_vkQueueWaitIdle, + pub device_wait_idle: PFN_vkDeviceWaitIdle, + pub allocate_memory: PFN_vkAllocateMemory, + pub free_memory: PFN_vkFreeMemory, + pub map_memory: PFN_vkMapMemory, + pub unmap_memory: PFN_vkUnmapMemory, + pub flush_mapped_memory_ranges: PFN_vkFlushMappedMemoryRanges, + pub invalidate_mapped_memory_ranges: PFN_vkInvalidateMappedMemoryRanges, + pub get_device_memory_commitment: PFN_vkGetDeviceMemoryCommitment, + pub bind_buffer_memory: PFN_vkBindBufferMemory, + pub bind_image_memory: PFN_vkBindImageMemory, + pub get_buffer_memory_requirements: PFN_vkGetBufferMemoryRequirements, + pub get_image_memory_requirements: PFN_vkGetImageMemoryRequirements, + pub get_image_sparse_memory_requirements: PFN_vkGetImageSparseMemoryRequirements, + pub queue_bind_sparse: PFN_vkQueueBindSparse, + pub create_fence: PFN_vkCreateFence, + pub destroy_fence: PFN_vkDestroyFence, + pub reset_fences: PFN_vkResetFences, + pub get_fence_status: PFN_vkGetFenceStatus, + pub wait_for_fences: PFN_vkWaitForFences, + pub create_semaphore: PFN_vkCreateSemaphore, + pub destroy_semaphore: PFN_vkDestroySemaphore, + pub create_event: PFN_vkCreateEvent, + pub destroy_event: PFN_vkDestroyEvent, + pub get_event_status: PFN_vkGetEventStatus, + pub set_event: PFN_vkSetEvent, + pub reset_event: PFN_vkResetEvent, + pub create_query_pool: PFN_vkCreateQueryPool, + pub destroy_query_pool: PFN_vkDestroyQueryPool, + pub get_query_pool_results: PFN_vkGetQueryPoolResults, + pub create_buffer: PFN_vkCreateBuffer, + pub destroy_buffer: PFN_vkDestroyBuffer, + pub create_buffer_view: PFN_vkCreateBufferView, + pub destroy_buffer_view: PFN_vkDestroyBufferView, + pub create_image: PFN_vkCreateImage, + pub destroy_image: PFN_vkDestroyImage, + pub get_image_subresource_layout: PFN_vkGetImageSubresourceLayout, + pub create_image_view: PFN_vkCreateImageView, + pub destroy_image_view: PFN_vkDestroyImageView, + pub create_shader_module: PFN_vkCreateShaderModule, + pub destroy_shader_module: PFN_vkDestroyShaderModule, + pub create_pipeline_cache: PFN_vkCreatePipelineCache, + pub destroy_pipeline_cache: PFN_vkDestroyPipelineCache, + pub get_pipeline_cache_data: PFN_vkGetPipelineCacheData, + pub merge_pipeline_caches: PFN_vkMergePipelineCaches, + pub create_graphics_pipelines: PFN_vkCreateGraphicsPipelines, + pub create_compute_pipelines: PFN_vkCreateComputePipelines, + pub destroy_pipeline: PFN_vkDestroyPipeline, + pub create_pipeline_layout: PFN_vkCreatePipelineLayout, + pub destroy_pipeline_layout: PFN_vkDestroyPipelineLayout, + pub create_sampler: PFN_vkCreateSampler, + pub destroy_sampler: PFN_vkDestroySampler, + pub create_descriptor_set_layout: PFN_vkCreateDescriptorSetLayout, + pub destroy_descriptor_set_layout: PFN_vkDestroyDescriptorSetLayout, + pub create_descriptor_pool: PFN_vkCreateDescriptorPool, + pub destroy_descriptor_pool: PFN_vkDestroyDescriptorPool, + pub reset_descriptor_pool: PFN_vkResetDescriptorPool, + pub allocate_descriptor_sets: PFN_vkAllocateDescriptorSets, + pub free_descriptor_sets: PFN_vkFreeDescriptorSets, + pub update_descriptor_sets: PFN_vkUpdateDescriptorSets, + pub create_framebuffer: PFN_vkCreateFramebuffer, + pub destroy_framebuffer: PFN_vkDestroyFramebuffer, + pub create_render_pass: PFN_vkCreateRenderPass, + pub destroy_render_pass: PFN_vkDestroyRenderPass, + pub get_render_area_granularity: PFN_vkGetRenderAreaGranularity, + pub create_command_pool: PFN_vkCreateCommandPool, + pub destroy_command_pool: PFN_vkDestroyCommandPool, + pub reset_command_pool: PFN_vkResetCommandPool, + pub allocate_command_buffers: PFN_vkAllocateCommandBuffers, + pub free_command_buffers: PFN_vkFreeCommandBuffers, + pub begin_command_buffer: PFN_vkBeginCommandBuffer, + pub end_command_buffer: PFN_vkEndCommandBuffer, + pub reset_command_buffer: PFN_vkResetCommandBuffer, + pub cmd_bind_pipeline: PFN_vkCmdBindPipeline, + pub cmd_set_viewport: PFN_vkCmdSetViewport, + pub cmd_set_scissor: PFN_vkCmdSetScissor, + pub cmd_set_line_width: PFN_vkCmdSetLineWidth, + pub cmd_set_depth_bias: PFN_vkCmdSetDepthBias, + pub cmd_set_blend_constants: PFN_vkCmdSetBlendConstants, + pub cmd_set_depth_bounds: PFN_vkCmdSetDepthBounds, + pub cmd_set_stencil_compare_mask: PFN_vkCmdSetStencilCompareMask, + pub cmd_set_stencil_write_mask: PFN_vkCmdSetStencilWriteMask, + pub cmd_set_stencil_reference: PFN_vkCmdSetStencilReference, + pub cmd_bind_descriptor_sets: PFN_vkCmdBindDescriptorSets, + pub cmd_bind_index_buffer: PFN_vkCmdBindIndexBuffer, + pub cmd_bind_vertex_buffers: PFN_vkCmdBindVertexBuffers, + pub cmd_draw: PFN_vkCmdDraw, + pub cmd_draw_indexed: PFN_vkCmdDrawIndexed, + pub cmd_draw_indirect: PFN_vkCmdDrawIndirect, + pub cmd_draw_indexed_indirect: PFN_vkCmdDrawIndexedIndirect, + pub cmd_dispatch: PFN_vkCmdDispatch, + pub cmd_dispatch_indirect: PFN_vkCmdDispatchIndirect, + pub cmd_copy_buffer: PFN_vkCmdCopyBuffer, + pub cmd_copy_image: PFN_vkCmdCopyImage, + pub cmd_blit_image: PFN_vkCmdBlitImage, + pub cmd_copy_buffer_to_image: PFN_vkCmdCopyBufferToImage, + pub cmd_copy_image_to_buffer: PFN_vkCmdCopyImageToBuffer, + pub cmd_update_buffer: PFN_vkCmdUpdateBuffer, + pub cmd_fill_buffer: PFN_vkCmdFillBuffer, + pub cmd_clear_color_image: PFN_vkCmdClearColorImage, + pub cmd_clear_depth_stencil_image: PFN_vkCmdClearDepthStencilImage, + pub cmd_clear_attachments: PFN_vkCmdClearAttachments, + pub cmd_resolve_image: PFN_vkCmdResolveImage, + pub cmd_set_event: PFN_vkCmdSetEvent, + pub cmd_reset_event: PFN_vkCmdResetEvent, + pub cmd_wait_events: PFN_vkCmdWaitEvents, + pub cmd_pipeline_barrier: PFN_vkCmdPipelineBarrier, + pub cmd_begin_query: PFN_vkCmdBeginQuery, + pub cmd_end_query: PFN_vkCmdEndQuery, + pub cmd_reset_query_pool: PFN_vkCmdResetQueryPool, + pub cmd_write_timestamp: PFN_vkCmdWriteTimestamp, + pub cmd_copy_query_pool_results: PFN_vkCmdCopyQueryPoolResults, + pub cmd_push_constants: PFN_vkCmdPushConstants, + pub cmd_begin_render_pass: PFN_vkCmdBeginRenderPass, + pub cmd_next_subpass: PFN_vkCmdNextSubpass, + pub cmd_end_render_pass: PFN_vkCmdEndRenderPass, + pub cmd_execute_commands: PFN_vkCmdExecuteCommands, +} +unsafe impl Send for DeviceFnV1_0 {} +unsafe impl Sync for DeviceFnV1_0 {} +impl DeviceFnV1_0 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + destroy_device: unsafe { + unsafe extern "system" fn destroy_device( + _device: Device, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_device))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDevice\0"); + let val = _f(cname); + if val.is_null() { + destroy_device + } else { + ::std::mem::transmute(val) + } + }, + get_device_queue: unsafe { + unsafe extern "system" fn get_device_queue( + _device: Device, + _queue_family_index: u32, + _queue_index: u32, + _p_queue: *mut Queue, + ) { + panic!(concat!("Unable to load ", stringify!(get_device_queue))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue\0"); + let val = _f(cname); + if val.is_null() { + get_device_queue + } else { + ::std::mem::transmute(val) + } + }, + queue_submit: unsafe { + unsafe extern "system" fn queue_submit( + _queue: Queue, + _submit_count: u32, + _p_submits: *const SubmitInfo, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_submit))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit\0"); + let val = _f(cname); + if val.is_null() { + queue_submit + } else { + ::std::mem::transmute(val) + } + }, + queue_wait_idle: unsafe { + unsafe extern "system" fn queue_wait_idle(_queue: Queue) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_wait_idle))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueWaitIdle\0"); + let val = _f(cname); + if val.is_null() { + queue_wait_idle + } else { + ::std::mem::transmute(val) + } + }, + device_wait_idle: unsafe { + unsafe extern "system" fn device_wait_idle(_device: Device) -> Result { + panic!(concat!("Unable to load ", stringify!(device_wait_idle))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDeviceWaitIdle\0"); + let val = _f(cname); + if val.is_null() { + device_wait_idle + } else { + ::std::mem::transmute(val) + } + }, + allocate_memory: unsafe { + unsafe extern "system" fn allocate_memory( + _device: Device, + _p_allocate_info: *const MemoryAllocateInfo, + _p_allocator: *const AllocationCallbacks, + _p_memory: *mut DeviceMemory, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(allocate_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateMemory\0"); + let val = _f(cname); + if val.is_null() { + allocate_memory + } else { + ::std::mem::transmute(val) + } + }, + free_memory: unsafe { + unsafe extern "system" fn free_memory( + _device: Device, + _memory: DeviceMemory, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(free_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeMemory\0"); + let val = _f(cname); + if val.is_null() { + free_memory + } else { + ::std::mem::transmute(val) + } + }, + map_memory: unsafe { + unsafe extern "system" fn map_memory( + _device: Device, + _memory: DeviceMemory, + _offset: DeviceSize, + _size: DeviceSize, + _flags: MemoryMapFlags, + _pp_data: *mut *mut c_void, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(map_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMapMemory\0"); + let val = _f(cname); + if val.is_null() { + map_memory + } else { + ::std::mem::transmute(val) + } + }, + unmap_memory: unsafe { + unsafe extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) { + panic!(concat!("Unable to load ", stringify!(unmap_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory\0"); + let val = _f(cname); + if val.is_null() { + unmap_memory + } else { + ::std::mem::transmute(val) + } + }, + flush_mapped_memory_ranges: unsafe { + unsafe extern "system" fn flush_mapped_memory_ranges( + _device: Device, + _memory_range_count: u32, + _p_memory_ranges: *const MappedMemoryRange, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(flush_mapped_memory_ranges) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFlushMappedMemoryRanges\0"); + let val = _f(cname); + if val.is_null() { + flush_mapped_memory_ranges + } else { + ::std::mem::transmute(val) + } + }, + invalidate_mapped_memory_ranges: unsafe { + unsafe extern "system" fn invalidate_mapped_memory_ranges( + _device: Device, + _memory_range_count: u32, + _p_memory_ranges: *const MappedMemoryRange, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(invalidate_mapped_memory_ranges) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkInvalidateMappedMemoryRanges\0", + ); + let val = _f(cname); + if val.is_null() { + invalidate_mapped_memory_ranges + } else { + ::std::mem::transmute(val) + } + }, + get_device_memory_commitment: unsafe { + unsafe extern "system" fn get_device_memory_commitment( + _device: Device, + _memory: DeviceMemory, + _p_committed_memory_in_bytes: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_memory_commitment) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMemoryCommitment\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_memory_commitment + } else { + ::std::mem::transmute(val) + } + }, + bind_buffer_memory: unsafe { + unsafe extern "system" fn bind_buffer_memory( + _device: Device, + _buffer: Buffer, + _memory: DeviceMemory, + _memory_offset: DeviceSize, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(bind_buffer_memory))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory\0"); + let val = _f(cname); + if val.is_null() { + bind_buffer_memory + } else { + ::std::mem::transmute(val) + } + }, + bind_image_memory: unsafe { + unsafe extern "system" fn bind_image_memory( + _device: Device, + _image: Image, + _memory: DeviceMemory, + _memory_offset: DeviceSize, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(bind_image_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory\0"); + let val = _f(cname); + if val.is_null() { + bind_image_memory + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_memory_requirements: unsafe { + unsafe extern "system" fn get_buffer_memory_requirements( + _device: Device, + _buffer: Buffer, + _p_memory_requirements: *mut MemoryRequirements, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + get_image_memory_requirements: unsafe { + unsafe extern "system" fn get_image_memory_requirements( + _device: Device, + _image: Image, + _p_memory_requirements: *mut MemoryRequirements, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + get_image_sparse_memory_requirements: unsafe { + unsafe extern "system" fn get_image_sparse_memory_requirements( + _device: Device, + _image: Image, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_sparse_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSparseMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_sparse_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + queue_bind_sparse: unsafe { + unsafe extern "system" fn queue_bind_sparse( + _queue: Queue, + _bind_info_count: u32, + _p_bind_info: *const BindSparseInfo, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_bind_sparse))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueBindSparse\0"); + let val = _f(cname); + if val.is_null() { + queue_bind_sparse + } else { + ::std::mem::transmute(val) + } + }, + create_fence: unsafe { + unsafe extern "system" fn create_fence( + _device: Device, + _p_create_info: *const FenceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_fence))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFence\0"); + let val = _f(cname); + if val.is_null() { + create_fence + } else { + ::std::mem::transmute(val) + } + }, + destroy_fence: unsafe { + unsafe extern "system" fn destroy_fence( + _device: Device, + _fence: Fence, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_fence))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFence\0"); + let val = _f(cname); + if val.is_null() { + destroy_fence + } else { + ::std::mem::transmute(val) + } + }, + reset_fences: unsafe { + unsafe extern "system" fn reset_fences( + _device: Device, + _fence_count: u32, + _p_fences: *const Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(reset_fences))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetFences\0"); + let val = _f(cname); + if val.is_null() { + reset_fences + } else { + ::std::mem::transmute(val) + } + }, + get_fence_status: unsafe { + unsafe extern "system" fn get_fence_status( + _device: Device, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_fence_status))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceStatus\0"); + let val = _f(cname); + if val.is_null() { + get_fence_status + } else { + ::std::mem::transmute(val) + } + }, + wait_for_fences: unsafe { + unsafe extern "system" fn wait_for_fences( + _device: Device, + _fence_count: u32, + _p_fences: *const Fence, + _wait_all: Bool32, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_for_fences))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForFences\0"); + let val = _f(cname); + if val.is_null() { + wait_for_fences + } else { + ::std::mem::transmute(val) + } + }, + create_semaphore: unsafe { + unsafe extern "system" fn create_semaphore( + _device: Device, + _p_create_info: *const SemaphoreCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_semaphore: *mut Semaphore, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_semaphore))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSemaphore\0"); + let val = _f(cname); + if val.is_null() { + create_semaphore + } else { + ::std::mem::transmute(val) + } + }, + destroy_semaphore: unsafe { + unsafe extern "system" fn destroy_semaphore( + _device: Device, + _semaphore: Semaphore, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_semaphore))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySemaphore\0"); + let val = _f(cname); + if val.is_null() { + destroy_semaphore + } else { + ::std::mem::transmute(val) + } + }, + create_event: unsafe { + unsafe extern "system" fn create_event( + _device: Device, + _p_create_info: *const EventCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_event: *mut Event, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateEvent\0"); + let val = _f(cname); + if val.is_null() { + create_event + } else { + ::std::mem::transmute(val) + } + }, + destroy_event: unsafe { + unsafe extern "system" fn destroy_event( + _device: Device, + _event: Event, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyEvent\0"); + let val = _f(cname); + if val.is_null() { + destroy_event + } else { + ::std::mem::transmute(val) + } + }, + get_event_status: unsafe { + unsafe extern "system" fn get_event_status( + _device: Device, + _event: Event, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_event_status))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetEventStatus\0"); + let val = _f(cname); + if val.is_null() { + get_event_status + } else { + ::std::mem::transmute(val) + } + }, + set_event: unsafe { + unsafe extern "system" fn set_event(_device: Device, _event: Event) -> Result { + panic!(concat!("Unable to load ", stringify!(set_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetEvent\0"); + let val = _f(cname); + if val.is_null() { + set_event + } else { + ::std::mem::transmute(val) + } + }, + reset_event: unsafe { + unsafe extern "system" fn reset_event(_device: Device, _event: Event) -> Result { + panic!(concat!("Unable to load ", stringify!(reset_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetEvent\0"); + let val = _f(cname); + if val.is_null() { + reset_event + } else { + ::std::mem::transmute(val) + } + }, + create_query_pool: unsafe { + unsafe extern "system" fn create_query_pool( + _device: Device, + _p_create_info: *const QueryPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_query_pool: *mut QueryPool, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_query_pool))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateQueryPool\0"); + let val = _f(cname); + if val.is_null() { + create_query_pool + } else { + ::std::mem::transmute(val) + } + }, + destroy_query_pool: unsafe { + unsafe extern "system" fn destroy_query_pool( + _device: Device, + _query_pool: QueryPool, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_query_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyQueryPool\0"); + let val = _f(cname); + if val.is_null() { + destroy_query_pool + } else { + ::std::mem::transmute(val) + } + }, + get_query_pool_results: unsafe { + unsafe extern "system" fn get_query_pool_results( + _device: Device, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + _data_size: usize, + _p_data: *mut c_void, + _stride: DeviceSize, + _flags: QueryResultFlags, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_query_pool_results) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetQueryPoolResults\0"); + let val = _f(cname); + if val.is_null() { + get_query_pool_results + } else { + ::std::mem::transmute(val) + } + }, + create_buffer: unsafe { + unsafe extern "system" fn create_buffer( + _device: Device, + _p_create_info: *const BufferCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_buffer: *mut Buffer, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBuffer\0"); + let val = _f(cname); + if val.is_null() { + create_buffer + } else { + ::std::mem::transmute(val) + } + }, + destroy_buffer: unsafe { + unsafe extern "system" fn destroy_buffer( + _device: Device, + _buffer: Buffer, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBuffer\0"); + let val = _f(cname); + if val.is_null() { + destroy_buffer + } else { + ::std::mem::transmute(val) + } + }, + create_buffer_view: unsafe { + unsafe extern "system" fn create_buffer_view( + _device: Device, + _p_create_info: *const BufferViewCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_view: *mut BufferView, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_buffer_view))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBufferView\0"); + let val = _f(cname); + if val.is_null() { + create_buffer_view + } else { + ::std::mem::transmute(val) + } + }, + destroy_buffer_view: unsafe { + unsafe extern "system" fn destroy_buffer_view( + _device: Device, + _buffer_view: BufferView, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_buffer_view))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBufferView\0"); + let val = _f(cname); + if val.is_null() { + destroy_buffer_view + } else { + ::std::mem::transmute(val) + } + }, + create_image: unsafe { + unsafe extern "system" fn create_image( + _device: Device, + _p_create_info: *const ImageCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_image: *mut Image, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImage\0"); + let val = _f(cname); + if val.is_null() { + create_image + } else { + ::std::mem::transmute(val) + } + }, + destroy_image: unsafe { + unsafe extern "system" fn destroy_image( + _device: Device, + _image: Image, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImage\0"); + let val = _f(cname); + if val.is_null() { + destroy_image + } else { + ::std::mem::transmute(val) + } + }, + get_image_subresource_layout: unsafe { + unsafe extern "system" fn get_image_subresource_layout( + _device: Device, + _image: Image, + _p_subresource: *const ImageSubresource, + _p_layout: *mut SubresourceLayout, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_subresource_layout) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSubresourceLayout\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_subresource_layout + } else { + ::std::mem::transmute(val) + } + }, + create_image_view: unsafe { + unsafe extern "system" fn create_image_view( + _device: Device, + _p_create_info: *const ImageViewCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_view: *mut ImageView, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_image_view))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImageView\0"); + let val = _f(cname); + if val.is_null() { + create_image_view + } else { + ::std::mem::transmute(val) + } + }, + destroy_image_view: unsafe { + unsafe extern "system" fn destroy_image_view( + _device: Device, + _image_view: ImageView, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_image_view))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImageView\0"); + let val = _f(cname); + if val.is_null() { + destroy_image_view + } else { + ::std::mem::transmute(val) + } + }, + create_shader_module: unsafe { + unsafe extern "system" fn create_shader_module( + _device: Device, + _p_create_info: *const ShaderModuleCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_shader_module: *mut ShaderModule, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_shader_module))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShaderModule\0"); + let val = _f(cname); + if val.is_null() { + create_shader_module + } else { + ::std::mem::transmute(val) + } + }, + destroy_shader_module: unsafe { + unsafe extern "system" fn destroy_shader_module( + _device: Device, + _shader_module: ShaderModule, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_shader_module) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderModule\0"); + let val = _f(cname); + if val.is_null() { + destroy_shader_module + } else { + ::std::mem::transmute(val) + } + }, + create_pipeline_cache: unsafe { + unsafe extern "system" fn create_pipeline_cache( + _device: Device, + _p_create_info: *const PipelineCacheCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipeline_cache: *mut PipelineCache, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_pipeline_cache) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineCache\0"); + let val = _f(cname); + if val.is_null() { + create_pipeline_cache + } else { + ::std::mem::transmute(val) + } + }, + destroy_pipeline_cache: unsafe { + unsafe extern "system" fn destroy_pipeline_cache( + _device: Device, + _pipeline_cache: PipelineCache, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_pipeline_cache) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineCache\0"); + let val = _f(cname); + if val.is_null() { + destroy_pipeline_cache + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_cache_data: unsafe { + unsafe extern "system" fn get_pipeline_cache_data( + _device: Device, + _pipeline_cache: PipelineCache, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_cache_data) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPipelineCacheData\0"); + let val = _f(cname); + if val.is_null() { + get_pipeline_cache_data + } else { + ::std::mem::transmute(val) + } + }, + merge_pipeline_caches: unsafe { + unsafe extern "system" fn merge_pipeline_caches( + _device: Device, + _dst_cache: PipelineCache, + _src_cache_count: u32, + _p_src_caches: *const PipelineCache, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(merge_pipeline_caches) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMergePipelineCaches\0"); + let val = _f(cname); + if val.is_null() { + merge_pipeline_caches + } else { + ::std::mem::transmute(val) + } + }, + create_graphics_pipelines: unsafe { + unsafe extern "system" fn create_graphics_pipelines( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const GraphicsPipelineCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_graphics_pipelines) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGraphicsPipelines\0"); + let val = _f(cname); + if val.is_null() { + create_graphics_pipelines + } else { + ::std::mem::transmute(val) + } + }, + create_compute_pipelines: unsafe { + unsafe extern "system" fn create_compute_pipelines( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const ComputePipelineCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_compute_pipelines) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateComputePipelines\0"); + let val = _f(cname); + if val.is_null() { + create_compute_pipelines + } else { + ::std::mem::transmute(val) + } + }, + destroy_pipeline: unsafe { + unsafe extern "system" fn destroy_pipeline( + _device: Device, + _pipeline: Pipeline, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_pipeline))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipeline\0"); + let val = _f(cname); + if val.is_null() { + destroy_pipeline + } else { + ::std::mem::transmute(val) + } + }, + create_pipeline_layout: unsafe { + unsafe extern "system" fn create_pipeline_layout( + _device: Device, + _p_create_info: *const PipelineLayoutCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipeline_layout: *mut PipelineLayout, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_pipeline_layout) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineLayout\0"); + let val = _f(cname); + if val.is_null() { + create_pipeline_layout + } else { + ::std::mem::transmute(val) + } + }, + destroy_pipeline_layout: unsafe { + unsafe extern "system" fn destroy_pipeline_layout( + _device: Device, + _pipeline_layout: PipelineLayout, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_pipeline_layout) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineLayout\0"); + let val = _f(cname); + if val.is_null() { + destroy_pipeline_layout + } else { + ::std::mem::transmute(val) + } + }, + create_sampler: unsafe { + unsafe extern "system" fn create_sampler( + _device: Device, + _p_create_info: *const SamplerCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_sampler: *mut Sampler, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_sampler))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSampler\0"); + let val = _f(cname); + if val.is_null() { + create_sampler + } else { + ::std::mem::transmute(val) + } + }, + destroy_sampler: unsafe { + unsafe extern "system" fn destroy_sampler( + _device: Device, + _sampler: Sampler, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_sampler))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySampler\0"); + let val = _f(cname); + if val.is_null() { + destroy_sampler + } else { + ::std::mem::transmute(val) + } + }, + create_descriptor_set_layout: unsafe { + unsafe extern "system" fn create_descriptor_set_layout( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_set_layout: *mut DescriptorSetLayout, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_set_layout) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDescriptorSetLayout\0", + ); + let val = _f(cname); + if val.is_null() { + create_descriptor_set_layout + } else { + ::std::mem::transmute(val) + } + }, + destroy_descriptor_set_layout: unsafe { + unsafe extern "system" fn destroy_descriptor_set_layout( + _device: Device, + _descriptor_set_layout: DescriptorSetLayout, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_set_layout) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDescriptorSetLayout\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_descriptor_set_layout + } else { + ::std::mem::transmute(val) + } + }, + create_descriptor_pool: unsafe { + unsafe extern "system" fn create_descriptor_pool( + _device: Device, + _p_create_info: *const DescriptorPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_descriptor_pool: *mut DescriptorPool, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_pool) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDescriptorPool\0"); + let val = _f(cname); + if val.is_null() { + create_descriptor_pool + } else { + ::std::mem::transmute(val) + } + }, + destroy_descriptor_pool: unsafe { + unsafe extern "system" fn destroy_descriptor_pool( + _device: Device, + _descriptor_pool: DescriptorPool, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_pool) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDescriptorPool\0"); + let val = _f(cname); + if val.is_null() { + destroy_descriptor_pool + } else { + ::std::mem::transmute(val) + } + }, + reset_descriptor_pool: unsafe { + unsafe extern "system" fn reset_descriptor_pool( + _device: Device, + _descriptor_pool: DescriptorPool, + _flags: DescriptorPoolResetFlags, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(reset_descriptor_pool) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetDescriptorPool\0"); + let val = _f(cname); + if val.is_null() { + reset_descriptor_pool + } else { + ::std::mem::transmute(val) + } + }, + allocate_descriptor_sets: unsafe { + unsafe extern "system" fn allocate_descriptor_sets( + _device: Device, + _p_allocate_info: *const DescriptorSetAllocateInfo, + _p_descriptor_sets: *mut DescriptorSet, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(allocate_descriptor_sets) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateDescriptorSets\0"); + let val = _f(cname); + if val.is_null() { + allocate_descriptor_sets + } else { + ::std::mem::transmute(val) + } + }, + free_descriptor_sets: unsafe { + unsafe extern "system" fn free_descriptor_sets( + _device: Device, + _descriptor_pool: DescriptorPool, + _descriptor_set_count: u32, + _p_descriptor_sets: *const DescriptorSet, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(free_descriptor_sets))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeDescriptorSets\0"); + let val = _f(cname); + if val.is_null() { + free_descriptor_sets + } else { + ::std::mem::transmute(val) + } + }, + update_descriptor_sets: unsafe { + unsafe extern "system" fn update_descriptor_sets( + _device: Device, + _descriptor_write_count: u32, + _p_descriptor_writes: *const WriteDescriptorSet, + _descriptor_copy_count: u32, + _p_descriptor_copies: *const CopyDescriptorSet, + ) { + panic!(concat!( + "Unable to load ", + stringify!(update_descriptor_sets) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUpdateDescriptorSets\0"); + let val = _f(cname); + if val.is_null() { + update_descriptor_sets + } else { + ::std::mem::transmute(val) + } + }, + create_framebuffer: unsafe { + unsafe extern "system" fn create_framebuffer( + _device: Device, + _p_create_info: *const FramebufferCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_framebuffer: *mut Framebuffer, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_framebuffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFramebuffer\0"); + let val = _f(cname); + if val.is_null() { + create_framebuffer + } else { + ::std::mem::transmute(val) + } + }, + destroy_framebuffer: unsafe { + unsafe extern "system" fn destroy_framebuffer( + _device: Device, + _framebuffer: Framebuffer, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_framebuffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFramebuffer\0"); + let val = _f(cname); + if val.is_null() { + destroy_framebuffer + } else { + ::std::mem::transmute(val) + } + }, + create_render_pass: unsafe { + unsafe extern "system" fn create_render_pass( + _device: Device, + _p_create_info: *const RenderPassCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_render_pass: *mut RenderPass, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_render_pass))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass\0"); + let val = _f(cname); + if val.is_null() { + create_render_pass + } else { + ::std::mem::transmute(val) + } + }, + destroy_render_pass: unsafe { + unsafe extern "system" fn destroy_render_pass( + _device: Device, + _render_pass: RenderPass, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_render_pass))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyRenderPass\0"); + let val = _f(cname); + if val.is_null() { + destroy_render_pass + } else { + ::std::mem::transmute(val) + } + }, + get_render_area_granularity: unsafe { + unsafe extern "system" fn get_render_area_granularity( + _device: Device, + _render_pass: RenderPass, + _p_granularity: *mut Extent2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_render_area_granularity) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRenderAreaGranularity\0", + ); + let val = _f(cname); + if val.is_null() { + get_render_area_granularity + } else { + ::std::mem::transmute(val) + } + }, + create_command_pool: unsafe { + unsafe extern "system" fn create_command_pool( + _device: Device, + _p_create_info: *const CommandPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_command_pool: *mut CommandPool, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_command_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCommandPool\0"); + let val = _f(cname); + if val.is_null() { + create_command_pool + } else { + ::std::mem::transmute(val) + } + }, + destroy_command_pool: unsafe { + unsafe extern "system" fn destroy_command_pool( + _device: Device, + _command_pool: CommandPool, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_command_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCommandPool\0"); + let val = _f(cname); + if val.is_null() { + destroy_command_pool + } else { + ::std::mem::transmute(val) + } + }, + reset_command_pool: unsafe { + unsafe extern "system" fn reset_command_pool( + _device: Device, + _command_pool: CommandPool, + _flags: CommandPoolResetFlags, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(reset_command_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandPool\0"); + let val = _f(cname); + if val.is_null() { + reset_command_pool + } else { + ::std::mem::transmute(val) + } + }, + allocate_command_buffers: unsafe { + unsafe extern "system" fn allocate_command_buffers( + _device: Device, + _p_allocate_info: *const CommandBufferAllocateInfo, + _p_command_buffers: *mut CommandBuffer, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(allocate_command_buffers) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateCommandBuffers\0"); + let val = _f(cname); + if val.is_null() { + allocate_command_buffers + } else { + ::std::mem::transmute(val) + } + }, + free_command_buffers: unsafe { + unsafe extern "system" fn free_command_buffers( + _device: Device, + _command_pool: CommandPool, + _command_buffer_count: u32, + _p_command_buffers: *const CommandBuffer, + ) { + panic!(concat!("Unable to load ", stringify!(free_command_buffers))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeCommandBuffers\0"); + let val = _f(cname); + if val.is_null() { + free_command_buffers + } else { + ::std::mem::transmute(val) + } + }, + begin_command_buffer: unsafe { + unsafe extern "system" fn begin_command_buffer( + _command_buffer: CommandBuffer, + _p_begin_info: *const CommandBufferBeginInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(begin_command_buffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBeginCommandBuffer\0"); + let val = _f(cname); + if val.is_null() { + begin_command_buffer + } else { + ::std::mem::transmute(val) + } + }, + end_command_buffer: unsafe { + unsafe extern "system" fn end_command_buffer( + _command_buffer: CommandBuffer, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(end_command_buffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkEndCommandBuffer\0"); + let val = _f(cname); + if val.is_null() { + end_command_buffer + } else { + ::std::mem::transmute(val) + } + }, + reset_command_buffer: unsafe { + unsafe extern "system" fn reset_command_buffer( + _command_buffer: CommandBuffer, + _flags: CommandBufferResetFlags, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(reset_command_buffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandBuffer\0"); + let val = _f(cname); + if val.is_null() { + reset_command_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_pipeline: unsafe { + unsafe extern "system" fn cmd_bind_pipeline( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _pipeline: Pipeline, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_bind_pipeline))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindPipeline\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_pipeline + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport: unsafe { + unsafe extern "system" fn cmd_set_viewport( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewports: *const Viewport, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_viewport))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewport\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_scissor: unsafe { + unsafe extern "system" fn cmd_set_scissor( + _command_buffer: CommandBuffer, + _first_scissor: u32, + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_scissor))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissor\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_scissor + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_width: unsafe { + unsafe extern "system" fn cmd_set_line_width( + _command_buffer: CommandBuffer, + _line_width: f32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_line_width))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineWidth\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_line_width + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bias: unsafe { + unsafe extern "system" fn cmd_set_depth_bias( + _command_buffer: CommandBuffer, + _depth_bias_constant_factor: f32, + _depth_bias_clamp: f32, + _depth_bias_slope_factor: f32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_blend_constants: unsafe { + unsafe extern "system" fn cmd_set_blend_constants( + _command_buffer: CommandBuffer, + _blend_constants: *const [f32; 4], + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_blend_constants) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetBlendConstants\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_blend_constants + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bounds: unsafe { + unsafe extern "system" fn cmd_set_depth_bounds( + _command_buffer: CommandBuffer, + _min_depth_bounds: f32, + _max_depth_bounds: f32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBounds\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bounds + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_compare_mask: unsafe { + unsafe extern "system" fn cmd_set_stencil_compare_mask( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _compare_mask: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_compare_mask) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetStencilCompareMask\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_compare_mask + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_write_mask: unsafe { + unsafe extern "system" fn cmd_set_stencil_write_mask( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _write_mask: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_write_mask) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilWriteMask\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_write_mask + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_reference: unsafe { + unsafe extern "system" fn cmd_set_stencil_reference( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _reference: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_reference) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilReference\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_reference + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_sets: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_sets( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _first_set: u32, + _descriptor_set_count: u32, + _p_descriptor_sets: *const DescriptorSet, + _dynamic_offset_count: u32, + _p_dynamic_offsets: *const u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_sets) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorSets\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_sets + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_index_buffer: unsafe { + unsafe extern "system" fn cmd_bind_index_buffer( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _index_type: IndexType, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_index_buffer) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindIndexBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_index_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_vertex_buffers: unsafe { + unsafe extern "system" fn cmd_bind_vertex_buffers( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_vertex_buffers) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_vertex_buffers + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw: unsafe { + unsafe extern "system" fn cmd_draw( + _command_buffer: CommandBuffer, + _vertex_count: u32, + _instance_count: u32, + _first_vertex: u32, + _first_instance: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_draw))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDraw\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed: unsafe { + unsafe extern "system" fn cmd_draw_indexed( + _command_buffer: CommandBuffer, + _index_count: u32, + _instance_count: u32, + _first_index: u32, + _vertex_offset: i32, + _first_instance: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_draw_indexed))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexed\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indirect: unsafe { + unsafe extern "system" fn cmd_draw_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_draw_indirect))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirect\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect: unsafe { + unsafe extern "system" fn cmd_draw_indexed_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexedIndirect\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed_indirect + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch: unsafe { + unsafe extern "system" fn cmd_dispatch( + _command_buffer: CommandBuffer, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_dispatch))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatch\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_indirect: unsafe { + unsafe extern "system" fn cmd_dispatch_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_dispatch_indirect) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchIndirect\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_indirect + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer: unsafe { + unsafe extern "system" fn cmd_copy_buffer( + _command_buffer: CommandBuffer, + _src_buffer: Buffer, + _dst_buffer: Buffer, + _region_count: u32, + _p_regions: *const BufferCopy, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image: unsafe { + unsafe extern "system" fn cmd_copy_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageCopy, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_blit_image: unsafe { + unsafe extern "system" fn cmd_blit_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageBlit, + _filter: Filter, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_blit_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_blit_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer_to_image: unsafe { + unsafe extern "system" fn cmd_copy_buffer_to_image( + _command_buffer: CommandBuffer, + _src_buffer: Buffer, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const BufferImageCopy, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_buffer_to_image) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer_to_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image_to_buffer: unsafe { + unsafe extern "system" fn cmd_copy_image_to_buffer( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_buffer: Buffer, + _region_count: u32, + _p_regions: *const BufferImageCopy, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_image_to_buffer) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image_to_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_update_buffer: unsafe { + unsafe extern "system" fn cmd_update_buffer( + _command_buffer: CommandBuffer, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _data_size: DeviceSize, + _p_data: *const c_void, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_update_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdUpdateBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_update_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_fill_buffer: unsafe { + unsafe extern "system" fn cmd_fill_buffer( + _command_buffer: CommandBuffer, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _size: DeviceSize, + _data: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_fill_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdFillBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_fill_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_clear_color_image: unsafe { + unsafe extern "system" fn cmd_clear_color_image( + _command_buffer: CommandBuffer, + _image: Image, + _image_layout: ImageLayout, + _p_color: *const ClearColorValue, + _range_count: u32, + _p_ranges: *const ImageSubresourceRange, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_clear_color_image) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearColorImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_clear_color_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_clear_depth_stencil_image: unsafe { + unsafe extern "system" fn cmd_clear_depth_stencil_image( + _command_buffer: CommandBuffer, + _image: Image, + _image_layout: ImageLayout, + _p_depth_stencil: *const ClearDepthStencilValue, + _range_count: u32, + _p_ranges: *const ImageSubresourceRange, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_clear_depth_stencil_image) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdClearDepthStencilImage\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_clear_depth_stencil_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_clear_attachments: unsafe { + unsafe extern "system" fn cmd_clear_attachments( + _command_buffer: CommandBuffer, + _attachment_count: u32, + _p_attachments: *const ClearAttachment, + _rect_count: u32, + _p_rects: *const ClearRect, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_clear_attachments) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearAttachments\0"); + let val = _f(cname); + if val.is_null() { + cmd_clear_attachments + } else { + ::std::mem::transmute(val) + } + }, + cmd_resolve_image: unsafe { + unsafe extern "system" fn cmd_resolve_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageResolve, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_resolve_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_resolve_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_event: unsafe { + unsafe extern "system" fn cmd_set_event( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_event + } else { + ::std::mem::transmute(val) + } + }, + cmd_reset_event: unsafe { + unsafe extern "system" fn cmd_reset_event( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_reset_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent\0"); + let val = _f(cname); + if val.is_null() { + cmd_reset_event + } else { + ::std::mem::transmute(val) + } + }, + cmd_wait_events: unsafe { + unsafe extern "system" fn cmd_wait_events( + _command_buffer: CommandBuffer, + _event_count: u32, + _p_events: *const Event, + _src_stage_mask: PipelineStageFlags, + _dst_stage_mask: PipelineStageFlags, + _memory_barrier_count: u32, + _p_memory_barriers: *const MemoryBarrier, + _buffer_memory_barrier_count: u32, + _p_buffer_memory_barriers: *const BufferMemoryBarrier, + _image_memory_barrier_count: u32, + _p_image_memory_barriers: *const ImageMemoryBarrier, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_wait_events))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents\0"); + let val = _f(cname); + if val.is_null() { + cmd_wait_events + } else { + ::std::mem::transmute(val) + } + }, + cmd_pipeline_barrier: unsafe { + unsafe extern "system" fn cmd_pipeline_barrier( + _command_buffer: CommandBuffer, + _src_stage_mask: PipelineStageFlags, + _dst_stage_mask: PipelineStageFlags, + _dependency_flags: DependencyFlags, + _memory_barrier_count: u32, + _p_memory_barriers: *const MemoryBarrier, + _buffer_memory_barrier_count: u32, + _p_buffer_memory_barriers: *const BufferMemoryBarrier, + _image_memory_barrier_count: u32, + _p_image_memory_barriers: *const ImageMemoryBarrier, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_pipeline_barrier))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier\0"); + let val = _f(cname); + if val.is_null() { + cmd_pipeline_barrier + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_query: unsafe { + unsafe extern "system" fn cmd_begin_query( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + _flags: QueryControlFlags, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_begin_query))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQuery\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_query + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_query: unsafe { + unsafe extern "system" fn cmd_end_query( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_end_query))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQuery\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_query + } else { + ::std::mem::transmute(val) + } + }, + cmd_reset_query_pool: unsafe { + unsafe extern "system" fn cmd_reset_query_pool( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_reset_query_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetQueryPool\0"); + let val = _f(cname); + if val.is_null() { + cmd_reset_query_pool + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_timestamp: unsafe { + unsafe extern "system" fn cmd_write_timestamp( + _command_buffer: CommandBuffer, + _pipeline_stage: PipelineStageFlags, + _query_pool: QueryPool, + _query: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp\0"); + let val = _f(cname); + if val.is_null() { + cmd_write_timestamp + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_query_pool_results: unsafe { + unsafe extern "system" fn cmd_copy_query_pool_results( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _stride: DeviceSize, + _flags: QueryResultFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_query_pool_results) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyQueryPoolResults\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_query_pool_results + } else { + ::std::mem::transmute(val) + } + }, + cmd_push_constants: unsafe { + unsafe extern "system" fn cmd_push_constants( + _command_buffer: CommandBuffer, + _layout: PipelineLayout, + _stage_flags: ShaderStageFlags, + _offset: u32, + _size: u32, + _p_values: *const c_void, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_push_constants))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushConstants\0"); + let val = _f(cname); + if val.is_null() { + cmd_push_constants + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_render_pass: unsafe { + unsafe extern "system" fn cmd_begin_render_pass( + _command_buffer: CommandBuffer, + _p_render_pass_begin: *const RenderPassBeginInfo, + _contents: SubpassContents, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_render_pass) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_render_pass + } else { + ::std::mem::transmute(val) + } + }, + cmd_next_subpass: unsafe { + unsafe extern "system" fn cmd_next_subpass( + _command_buffer: CommandBuffer, + _contents: SubpassContents, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_next_subpass))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass\0"); + let val = _f(cname); + if val.is_null() { + cmd_next_subpass + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_render_pass: unsafe { + unsafe extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) { + panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_render_pass + } else { + ::std::mem::transmute(val) + } + }, + cmd_execute_commands: unsafe { + unsafe extern "system" fn cmd_execute_commands( + _command_buffer: CommandBuffer, + _command_buffer_count: u32, + _p_command_buffers: *const CommandBuffer, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_execute_commands))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdExecuteCommands\0"); + let val = _f(cname); + if val.is_null() { + cmd_execute_commands + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateInstanceVersion = + unsafe extern "system" fn(p_api_version: *mut u32) -> Result; +#[derive(Clone)] +pub struct EntryFnV1_1 { + pub enumerate_instance_version: PFN_vkEnumerateInstanceVersion, +} +unsafe impl Send for EntryFnV1_1 {} +unsafe impl Sync for EntryFnV1_1 {} +impl EntryFnV1_1 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + enumerate_instance_version: unsafe { + unsafe extern "system" fn enumerate_instance_version( + _p_api_version: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_instance_version) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateInstanceVersion\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_instance_version + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[derive(Clone)] +pub struct InstanceFnV1_1 { + pub enumerate_physical_device_groups: crate::vk::PFN_vkEnumeratePhysicalDeviceGroups, + pub get_physical_device_features2: crate::vk::PFN_vkGetPhysicalDeviceFeatures2, + pub get_physical_device_properties2: crate::vk::PFN_vkGetPhysicalDeviceProperties2, + pub get_physical_device_format_properties2: crate::vk::PFN_vkGetPhysicalDeviceFormatProperties2, + pub get_physical_device_image_format_properties2: + crate::vk::PFN_vkGetPhysicalDeviceImageFormatProperties2, + pub get_physical_device_queue_family_properties2: + crate::vk::PFN_vkGetPhysicalDeviceQueueFamilyProperties2, + pub get_physical_device_memory_properties2: crate::vk::PFN_vkGetPhysicalDeviceMemoryProperties2, + pub get_physical_device_sparse_image_format_properties2: + crate::vk::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2, + pub get_physical_device_external_buffer_properties: + crate::vk::PFN_vkGetPhysicalDeviceExternalBufferProperties, + pub get_physical_device_external_fence_properties: + crate::vk::PFN_vkGetPhysicalDeviceExternalFenceProperties, + pub get_physical_device_external_semaphore_properties: + crate::vk::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties, +} +unsafe impl Send for InstanceFnV1_1 {} +unsafe impl Sync for InstanceFnV1_1 {} +impl InstanceFnV1_1 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + enumerate_physical_device_groups: unsafe { + unsafe extern "system" fn enumerate_physical_device_groups( + _instance: Instance, + _p_physical_device_group_count: *mut u32, + _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_physical_device_groups) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumeratePhysicalDeviceGroups\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_physical_device_groups + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_features2: unsafe { + unsafe extern "system" fn get_physical_device_features2( + _physical_device: PhysicalDevice, + _p_features: *mut PhysicalDeviceFeatures2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_features2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFeatures2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_features2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_properties2: unsafe { + unsafe extern "system" fn get_physical_device_properties2( + _physical_device: PhysicalDevice, + _p_properties: *mut PhysicalDeviceProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_format_properties2: unsafe { + unsafe extern "system" fn get_physical_device_format_properties2( + _physical_device: PhysicalDevice, + _format: Format, + _p_format_properties: *mut FormatProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_format_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFormatProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_format_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_image_format_properties2: unsafe { + unsafe extern "system" fn get_physical_device_image_format_properties2( + _physical_device: PhysicalDevice, + _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + _p_image_format_properties: *mut ImageFormatProperties2, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_image_format_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceImageFormatProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_image_format_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_queue_family_properties2: unsafe { + unsafe extern "system" fn get_physical_device_queue_family_properties2( + _physical_device: PhysicalDevice, + _p_queue_family_property_count: *mut u32, + _p_queue_family_properties: *mut QueueFamilyProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_queue_family_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceQueueFamilyProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_queue_family_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_memory_properties2: unsafe { + unsafe extern "system" fn get_physical_device_memory_properties2( + _physical_device: PhysicalDevice, + _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_memory_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceMemoryProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_memory_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_sparse_image_format_properties2: unsafe { + unsafe extern "system" fn get_physical_device_sparse_image_format_properties2( + _physical_device: PhysicalDevice, + _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + _p_property_count: *mut u32, + _p_properties: *mut SparseImageFormatProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_sparse_image_format_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSparseImageFormatProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_sparse_image_format_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_external_buffer_properties: unsafe { + unsafe extern "system" fn get_physical_device_external_buffer_properties( + _physical_device: PhysicalDevice, + _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + _p_external_buffer_properties: *mut ExternalBufferProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_buffer_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalBufferProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_buffer_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_external_fence_properties: unsafe { + unsafe extern "system" fn get_physical_device_external_fence_properties( + _physical_device: PhysicalDevice, + _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + _p_external_fence_properties: *mut ExternalFenceProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_fence_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalFenceProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_fence_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_external_semaphore_properties: unsafe { + unsafe extern "system" fn get_physical_device_external_semaphore_properties( + _physical_device: PhysicalDevice, + _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_semaphore_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalSemaphoreProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_semaphore_properties + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceQueue2 = unsafe extern "system" fn( + device: Device, + p_queue_info: *const DeviceQueueInfo2, + p_queue: *mut Queue, +); +#[derive(Clone)] +pub struct DeviceFnV1_1 { + pub bind_buffer_memory2: crate::vk::PFN_vkBindBufferMemory2, + pub bind_image_memory2: crate::vk::PFN_vkBindImageMemory2, + pub get_device_group_peer_memory_features: crate::vk::PFN_vkGetDeviceGroupPeerMemoryFeatures, + pub cmd_set_device_mask: crate::vk::PFN_vkCmdSetDeviceMask, + pub cmd_dispatch_base: crate::vk::PFN_vkCmdDispatchBase, + pub get_image_memory_requirements2: crate::vk::PFN_vkGetImageMemoryRequirements2, + pub get_buffer_memory_requirements2: crate::vk::PFN_vkGetBufferMemoryRequirements2, + pub get_image_sparse_memory_requirements2: crate::vk::PFN_vkGetImageSparseMemoryRequirements2, + pub trim_command_pool: crate::vk::PFN_vkTrimCommandPool, + pub get_device_queue2: PFN_vkGetDeviceQueue2, + pub create_sampler_ycbcr_conversion: crate::vk::PFN_vkCreateSamplerYcbcrConversion, + pub destroy_sampler_ycbcr_conversion: crate::vk::PFN_vkDestroySamplerYcbcrConversion, + pub create_descriptor_update_template: crate::vk::PFN_vkCreateDescriptorUpdateTemplate, + pub destroy_descriptor_update_template: crate::vk::PFN_vkDestroyDescriptorUpdateTemplate, + pub update_descriptor_set_with_template: crate::vk::PFN_vkUpdateDescriptorSetWithTemplate, + pub get_descriptor_set_layout_support: crate::vk::PFN_vkGetDescriptorSetLayoutSupport, +} +unsafe impl Send for DeviceFnV1_1 {} +unsafe impl Sync for DeviceFnV1_1 {} +impl DeviceFnV1_1 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + bind_buffer_memory2: unsafe { + unsafe extern "system" fn bind_buffer_memory2( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindBufferMemoryInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(bind_buffer_memory2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2\0"); + let val = _f(cname); + if val.is_null() { + bind_buffer_memory2 + } else { + ::std::mem::transmute(val) + } + }, + bind_image_memory2: unsafe { + unsafe extern "system" fn bind_image_memory2( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindImageMemoryInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(bind_image_memory2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2\0"); + let val = _f(cname); + if val.is_null() { + bind_image_memory2 + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_peer_memory_features: unsafe { + unsafe extern "system" fn get_device_group_peer_memory_features( + _device: Device, + _heap_index: u32, + _local_device_index: u32, + _remote_device_index: u32, + _p_peer_memory_features: *mut PeerMemoryFeatureFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_peer_memory_features) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupPeerMemoryFeatures\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_peer_memory_features + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_device_mask: unsafe { + unsafe extern "system" fn cmd_set_device_mask( + _command_buffer: CommandBuffer, + _device_mask: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_device_mask))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMask\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_device_mask + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_base: unsafe { + unsafe extern "system" fn cmd_dispatch_base( + _command_buffer: CommandBuffer, + _base_group_x: u32, + _base_group_y: u32, + _base_group_z: u32, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_dispatch_base))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBase\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_base + } else { + ::std::mem::transmute(val) + } + }, + get_image_memory_requirements2: unsafe { + unsafe extern "system" fn get_image_memory_requirements2( + _device: Device, + _p_info: *const ImageMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_memory_requirements2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageMemoryRequirements2\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_memory_requirements2 + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_memory_requirements2: unsafe { + unsafe extern "system" fn get_buffer_memory_requirements2( + _device: Device, + _p_info: *const BufferMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_memory_requirements2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferMemoryRequirements2\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_memory_requirements2 + } else { + ::std::mem::transmute(val) + } + }, + get_image_sparse_memory_requirements2: unsafe { + unsafe extern "system" fn get_image_sparse_memory_requirements2( + _device: Device, + _p_info: *const ImageSparseMemoryRequirementsInfo2, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_sparse_memory_requirements2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSparseMemoryRequirements2\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_sparse_memory_requirements2 + } else { + ::std::mem::transmute(val) + } + }, + trim_command_pool: unsafe { + unsafe extern "system" fn trim_command_pool( + _device: Device, + _command_pool: CommandPool, + _flags: CommandPoolTrimFlags, + ) { + panic!(concat!("Unable to load ", stringify!(trim_command_pool))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPool\0"); + let val = _f(cname); + if val.is_null() { + trim_command_pool + } else { + ::std::mem::transmute(val) + } + }, + get_device_queue2: unsafe { + unsafe extern "system" fn get_device_queue2( + _device: Device, + _p_queue_info: *const DeviceQueueInfo2, + _p_queue: *mut Queue, + ) { + panic!(concat!("Unable to load ", stringify!(get_device_queue2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue2\0"); + let val = _f(cname); + if val.is_null() { + get_device_queue2 + } else { + ::std::mem::transmute(val) + } + }, + create_sampler_ycbcr_conversion: unsafe { + unsafe extern "system" fn create_sampler_ycbcr_conversion( + _device: Device, + _p_create_info: *const SamplerYcbcrConversionCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_ycbcr_conversion: *mut SamplerYcbcrConversion, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_sampler_ycbcr_conversion) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateSamplerYcbcrConversion\0", + ); + let val = _f(cname); + if val.is_null() { + create_sampler_ycbcr_conversion + } else { + ::std::mem::transmute(val) + } + }, + destroy_sampler_ycbcr_conversion: unsafe { + unsafe extern "system" fn destroy_sampler_ycbcr_conversion( + _device: Device, + _ycbcr_conversion: SamplerYcbcrConversion, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_sampler_ycbcr_conversion) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroySamplerYcbcrConversion\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_sampler_ycbcr_conversion + } else { + ::std::mem::transmute(val) + } + }, + create_descriptor_update_template: unsafe { + unsafe extern "system" fn create_descriptor_update_template( + _device: Device, + _p_create_info: *const DescriptorUpdateTemplateCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_descriptor_update_template: *mut DescriptorUpdateTemplate, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_update_template) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDescriptorUpdateTemplate\0", + ); + let val = _f(cname); + if val.is_null() { + create_descriptor_update_template + } else { + ::std::mem::transmute(val) + } + }, + destroy_descriptor_update_template: unsafe { + unsafe extern "system" fn destroy_descriptor_update_template( + _device: Device, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_update_template) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDescriptorUpdateTemplate\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_descriptor_update_template + } else { + ::std::mem::transmute(val) + } + }, + update_descriptor_set_with_template: unsafe { + unsafe extern "system" fn update_descriptor_set_with_template( + _device: Device, + _descriptor_set: DescriptorSet, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_data: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(update_descriptor_set_with_template) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkUpdateDescriptorSetWithTemplate\0", + ); + let val = _f(cname); + if val.is_null() { + update_descriptor_set_with_template + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_layout_support: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_support( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_support: *mut DescriptorSetLayoutSupport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_support) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutSupport\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_support + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[derive(Clone)] +pub struct EntryFnV1_2 {} +unsafe impl Send for EntryFnV1_2 {} +unsafe impl Sync for EntryFnV1_2 {} +impl EntryFnV1_2 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[derive(Clone)] +pub struct InstanceFnV1_2 {} +unsafe impl Send for InstanceFnV1_2 {} +unsafe impl Sync for InstanceFnV1_2 {} +impl InstanceFnV1_2 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[derive(Clone)] +pub struct DeviceFnV1_2 { + pub cmd_draw_indirect_count: crate::vk::PFN_vkCmdDrawIndirectCount, + pub cmd_draw_indexed_indirect_count: crate::vk::PFN_vkCmdDrawIndexedIndirectCount, + pub create_render_pass2: crate::vk::PFN_vkCreateRenderPass2, + pub cmd_begin_render_pass2: crate::vk::PFN_vkCmdBeginRenderPass2, + pub cmd_next_subpass2: crate::vk::PFN_vkCmdNextSubpass2, + pub cmd_end_render_pass2: crate::vk::PFN_vkCmdEndRenderPass2, + pub reset_query_pool: crate::vk::PFN_vkResetQueryPool, + pub get_semaphore_counter_value: crate::vk::PFN_vkGetSemaphoreCounterValue, + pub wait_semaphores: crate::vk::PFN_vkWaitSemaphores, + pub signal_semaphore: crate::vk::PFN_vkSignalSemaphore, + pub get_buffer_device_address: crate::vk::PFN_vkGetBufferDeviceAddress, + pub get_buffer_opaque_capture_address: crate::vk::PFN_vkGetBufferOpaqueCaptureAddress, + pub get_device_memory_opaque_capture_address: + crate::vk::PFN_vkGetDeviceMemoryOpaqueCaptureAddress, +} +unsafe impl Send for DeviceFnV1_2 {} +unsafe impl Sync for DeviceFnV1_2 {} +impl DeviceFnV1_2 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_indirect_count: unsafe { + unsafe extern "system" fn cmd_draw_indirect_count( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCount\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect_count + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect_count: unsafe { + unsafe extern "system" fn cmd_draw_indexed_indirect_count( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawIndexedIndirectCount\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed_indirect_count + } else { + ::std::mem::transmute(val) + } + }, + create_render_pass2: unsafe { + unsafe extern "system" fn create_render_pass2( + _device: Device, + _p_create_info: *const RenderPassCreateInfo2, + _p_allocator: *const AllocationCallbacks, + _p_render_pass: *mut RenderPass, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_render_pass2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2\0"); + let val = _f(cname); + if val.is_null() { + create_render_pass2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_render_pass2: unsafe { + unsafe extern "system" fn cmd_begin_render_pass2( + _command_buffer: CommandBuffer, + _p_render_pass_begin: *const RenderPassBeginInfo, + _p_subpass_begin_info: *const SubpassBeginInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_render_pass2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_render_pass2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_next_subpass2: unsafe { + unsafe extern "system" fn cmd_next_subpass2( + _command_buffer: CommandBuffer, + _p_subpass_begin_info: *const SubpassBeginInfo, + _p_subpass_end_info: *const SubpassEndInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_next_subpass2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2\0"); + let val = _f(cname); + if val.is_null() { + cmd_next_subpass2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_render_pass2: unsafe { + unsafe extern "system" fn cmd_end_render_pass2( + _command_buffer: CommandBuffer, + _p_subpass_end_info: *const SubpassEndInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_render_pass2 + } else { + ::std::mem::transmute(val) + } + }, + reset_query_pool: unsafe { + unsafe extern "system" fn reset_query_pool( + _device: Device, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + ) { + panic!(concat!("Unable to load ", stringify!(reset_query_pool))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPool\0"); + let val = _f(cname); + if val.is_null() { + reset_query_pool + } else { + ::std::mem::transmute(val) + } + }, + get_semaphore_counter_value: unsafe { + unsafe extern "system" fn get_semaphore_counter_value( + _device: Device, + _semaphore: Semaphore, + _p_value: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_counter_value) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSemaphoreCounterValue\0", + ); + let val = _f(cname); + if val.is_null() { + get_semaphore_counter_value + } else { + ::std::mem::transmute(val) + } + }, + wait_semaphores: unsafe { + unsafe extern "system" fn wait_semaphores( + _device: Device, + _p_wait_info: *const SemaphoreWaitInfo, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_semaphores))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphores\0"); + let val = _f(cname); + if val.is_null() { + wait_semaphores + } else { + ::std::mem::transmute(val) + } + }, + signal_semaphore: unsafe { + unsafe extern "system" fn signal_semaphore( + _device: Device, + _p_signal_info: *const SemaphoreSignalInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(signal_semaphore))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphore\0"); + let val = _f(cname); + if val.is_null() { + signal_semaphore + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_device_address: unsafe { + unsafe extern "system" fn get_buffer_device_address( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_device_address) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddress\0"); + let val = _f(cname); + if val.is_null() { + get_buffer_device_address + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_address: unsafe { + unsafe extern "system" fn get_buffer_opaque_capture_address( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_address) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferOpaqueCaptureAddress\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_opaque_capture_address + } else { + ::std::mem::transmute(val) + } + }, + get_device_memory_opaque_capture_address: unsafe { + unsafe extern "system" fn get_device_memory_opaque_capture_address( + _device: Device, + _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_device_memory_opaque_capture_address) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMemoryOpaqueCaptureAddress\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_memory_opaque_capture_address + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[derive(Clone)] +pub struct EntryFnV1_3 {} +unsafe impl Send for EntryFnV1_3 {} +unsafe impl Sync for EntryFnV1_3 {} +impl EntryFnV1_3 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[derive(Clone)] +pub struct InstanceFnV1_3 { + pub get_physical_device_tool_properties: crate::vk::PFN_vkGetPhysicalDeviceToolProperties, +} +unsafe impl Send for InstanceFnV1_3 {} +unsafe impl Sync for InstanceFnV1_3 {} +impl InstanceFnV1_3 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_tool_properties: unsafe { + unsafe extern "system" fn get_physical_device_tool_properties( + _physical_device: PhysicalDevice, + _p_tool_count: *mut u32, + _p_tool_properties: *mut PhysicalDeviceToolProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_tool_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceToolProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_tool_properties + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[derive(Clone)] +pub struct DeviceFnV1_3 { + pub create_private_data_slot: crate::vk::PFN_vkCreatePrivateDataSlot, + pub destroy_private_data_slot: crate::vk::PFN_vkDestroyPrivateDataSlot, + pub set_private_data: crate::vk::PFN_vkSetPrivateData, + pub get_private_data: crate::vk::PFN_vkGetPrivateData, + pub cmd_set_event2: crate::vk::PFN_vkCmdSetEvent2, + pub cmd_reset_event2: crate::vk::PFN_vkCmdResetEvent2, + pub cmd_wait_events2: crate::vk::PFN_vkCmdWaitEvents2, + pub cmd_pipeline_barrier2: crate::vk::PFN_vkCmdPipelineBarrier2, + pub cmd_write_timestamp2: crate::vk::PFN_vkCmdWriteTimestamp2, + pub queue_submit2: crate::vk::PFN_vkQueueSubmit2, + pub cmd_copy_buffer2: crate::vk::PFN_vkCmdCopyBuffer2, + pub cmd_copy_image2: crate::vk::PFN_vkCmdCopyImage2, + pub cmd_copy_buffer_to_image2: crate::vk::PFN_vkCmdCopyBufferToImage2, + pub cmd_copy_image_to_buffer2: crate::vk::PFN_vkCmdCopyImageToBuffer2, + pub cmd_blit_image2: crate::vk::PFN_vkCmdBlitImage2, + pub cmd_resolve_image2: crate::vk::PFN_vkCmdResolveImage2, + pub cmd_begin_rendering: crate::vk::PFN_vkCmdBeginRendering, + pub cmd_end_rendering: crate::vk::PFN_vkCmdEndRendering, + pub cmd_set_cull_mode: crate::vk::PFN_vkCmdSetCullMode, + pub cmd_set_front_face: crate::vk::PFN_vkCmdSetFrontFace, + pub cmd_set_primitive_topology: crate::vk::PFN_vkCmdSetPrimitiveTopology, + pub cmd_set_viewport_with_count: crate::vk::PFN_vkCmdSetViewportWithCount, + pub cmd_set_scissor_with_count: crate::vk::PFN_vkCmdSetScissorWithCount, + pub cmd_bind_vertex_buffers2: crate::vk::PFN_vkCmdBindVertexBuffers2, + pub cmd_set_depth_test_enable: crate::vk::PFN_vkCmdSetDepthTestEnable, + pub cmd_set_depth_write_enable: crate::vk::PFN_vkCmdSetDepthWriteEnable, + pub cmd_set_depth_compare_op: crate::vk::PFN_vkCmdSetDepthCompareOp, + pub cmd_set_depth_bounds_test_enable: crate::vk::PFN_vkCmdSetDepthBoundsTestEnable, + pub cmd_set_stencil_test_enable: crate::vk::PFN_vkCmdSetStencilTestEnable, + pub cmd_set_stencil_op: crate::vk::PFN_vkCmdSetStencilOp, + pub cmd_set_rasterizer_discard_enable: crate::vk::PFN_vkCmdSetRasterizerDiscardEnable, + pub cmd_set_depth_bias_enable: crate::vk::PFN_vkCmdSetDepthBiasEnable, + pub cmd_set_primitive_restart_enable: crate::vk::PFN_vkCmdSetPrimitiveRestartEnable, + pub get_device_buffer_memory_requirements: crate::vk::PFN_vkGetDeviceBufferMemoryRequirements, + pub get_device_image_memory_requirements: crate::vk::PFN_vkGetDeviceImageMemoryRequirements, + pub get_device_image_sparse_memory_requirements: + crate::vk::PFN_vkGetDeviceImageSparseMemoryRequirements, +} +unsafe impl Send for DeviceFnV1_3 {} +unsafe impl Sync for DeviceFnV1_3 {} +impl DeviceFnV1_3 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_private_data_slot: unsafe { + unsafe extern "system" fn create_private_data_slot( + _device: Device, + _p_create_info: *const PrivateDataSlotCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_private_data_slot: *mut PrivateDataSlot, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_private_data_slot) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePrivateDataSlot\0"); + let val = _f(cname); + if val.is_null() { + create_private_data_slot + } else { + ::std::mem::transmute(val) + } + }, + destroy_private_data_slot: unsafe { + unsafe extern "system" fn destroy_private_data_slot( + _device: Device, + _private_data_slot: PrivateDataSlot, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_private_data_slot) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlot\0"); + let val = _f(cname); + if val.is_null() { + destroy_private_data_slot + } else { + ::std::mem::transmute(val) + } + }, + set_private_data: unsafe { + unsafe extern "system" fn set_private_data( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlot, + _data: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(set_private_data))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateData\0"); + let val = _f(cname); + if val.is_null() { + set_private_data + } else { + ::std::mem::transmute(val) + } + }, + get_private_data: unsafe { + unsafe extern "system" fn get_private_data( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlot, + _p_data: *mut u64, + ) { + panic!(concat!("Unable to load ", stringify!(get_private_data))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateData\0"); + let val = _f(cname); + if val.is_null() { + get_private_data + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_event2: unsafe { + unsafe extern "system" fn cmd_set_event2( + _command_buffer: CommandBuffer, + _event: Event, + _p_dependency_info: *const DependencyInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_event2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_event2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_reset_event2: unsafe { + unsafe extern "system" fn cmd_reset_event2( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_reset_event2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2\0"); + let val = _f(cname); + if val.is_null() { + cmd_reset_event2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_wait_events2: unsafe { + unsafe extern "system" fn cmd_wait_events2( + _command_buffer: CommandBuffer, + _event_count: u32, + _p_events: *const Event, + _p_dependency_infos: *const DependencyInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_wait_events2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2\0"); + let val = _f(cname); + if val.is_null() { + cmd_wait_events2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_pipeline_barrier2: unsafe { + unsafe extern "system" fn cmd_pipeline_barrier2( + _command_buffer: CommandBuffer, + _p_dependency_info: *const DependencyInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_pipeline_barrier2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2\0"); + let val = _f(cname); + if val.is_null() { + cmd_pipeline_barrier2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_timestamp2: unsafe { + unsafe extern "system" fn cmd_write_timestamp2( + _command_buffer: CommandBuffer, + _stage: PipelineStageFlags2, + _query_pool: QueryPool, + _query: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2\0"); + let val = _f(cname); + if val.is_null() { + cmd_write_timestamp2 + } else { + ::std::mem::transmute(val) + } + }, + queue_submit2: unsafe { + unsafe extern "system" fn queue_submit2( + _queue: Queue, + _submit_count: u32, + _p_submits: *const SubmitInfo2, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_submit2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2\0"); + let val = _f(cname); + if val.is_null() { + queue_submit2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer2: unsafe { + unsafe extern "system" fn cmd_copy_buffer2( + _command_buffer: CommandBuffer, + _p_copy_buffer_info: *const CopyBufferInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image2: unsafe { + unsafe extern "system" fn cmd_copy_image2( + _command_buffer: CommandBuffer, + _p_copy_image_info: *const CopyImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_image2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer_to_image2: unsafe { + unsafe extern "system" fn cmd_copy_buffer_to_image2( + _command_buffer: CommandBuffer, + _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_buffer_to_image2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage2\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer_to_image2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image_to_buffer2: unsafe { + unsafe extern "system" fn cmd_copy_image_to_buffer2( + _command_buffer: CommandBuffer, + _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_image_to_buffer2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer2\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image_to_buffer2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_blit_image2: unsafe { + unsafe extern "system" fn cmd_blit_image2( + _command_buffer: CommandBuffer, + _p_blit_image_info: *const BlitImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_blit_image2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2\0"); + let val = _f(cname); + if val.is_null() { + cmd_blit_image2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_resolve_image2: unsafe { + unsafe extern "system" fn cmd_resolve_image2( + _command_buffer: CommandBuffer, + _p_resolve_image_info: *const ResolveImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_resolve_image2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2\0"); + let val = _f(cname); + if val.is_null() { + cmd_resolve_image2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_rendering: unsafe { + unsafe extern "system" fn cmd_begin_rendering( + _command_buffer: CommandBuffer, + _p_rendering_info: *const RenderingInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_begin_rendering))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRendering\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_rendering + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_rendering: unsafe { + unsafe extern "system" fn cmd_end_rendering(_command_buffer: CommandBuffer) { + panic!(concat!("Unable to load ", stringify!(cmd_end_rendering))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRendering\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_rendering + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_cull_mode: unsafe { + unsafe extern "system" fn cmd_set_cull_mode( + _command_buffer: CommandBuffer, + _cull_mode: CullModeFlags, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_cull_mode))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullMode\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_cull_mode + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_front_face: unsafe { + unsafe extern "system" fn cmd_set_front_face( + _command_buffer: CommandBuffer, + _front_face: FrontFace, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_front_face))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFace\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_front_face + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_topology: unsafe { + unsafe extern "system" fn cmd_set_primitive_topology( + _command_buffer: CommandBuffer, + _primitive_topology: PrimitiveTopology, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_topology) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopology\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_topology + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_with_count: unsafe { + unsafe extern "system" fn cmd_set_viewport_with_count( + _command_buffer: CommandBuffer, + _viewport_count: u32, + _p_viewports: *const Viewport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_with_count) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCount\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_with_count + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_scissor_with_count: unsafe { + unsafe extern "system" fn cmd_set_scissor_with_count( + _command_buffer: CommandBuffer, + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_scissor_with_count) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCount\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_scissor_with_count + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_vertex_buffers2: unsafe { + unsafe extern "system" fn cmd_bind_vertex_buffers2( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + _p_sizes: *const DeviceSize, + _p_strides: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_vertex_buffers2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_vertex_buffers2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_test_enable: unsafe { + unsafe extern "system" fn cmd_set_depth_test_enable( + _command_buffer: CommandBuffer, + _depth_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_test_enable) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnable\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_test_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_write_enable: unsafe { + unsafe extern "system" fn cmd_set_depth_write_enable( + _command_buffer: CommandBuffer, + _depth_write_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_write_enable) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnable\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_write_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_compare_op: unsafe { + unsafe extern "system" fn cmd_set_depth_compare_op( + _command_buffer: CommandBuffer, + _depth_compare_op: CompareOp, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_compare_op) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOp\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_compare_op + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bounds_test_enable: unsafe { + unsafe extern "system" fn cmd_set_depth_bounds_test_enable( + _command_buffer: CommandBuffer, + _depth_bounds_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bounds_test_enable) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBoundsTestEnable\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bounds_test_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_test_enable: unsafe { + unsafe extern "system" fn cmd_set_stencil_test_enable( + _command_buffer: CommandBuffer, + _stencil_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_test_enable) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnable\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_test_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_op: unsafe { + unsafe extern "system" fn cmd_set_stencil_op( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _fail_op: StencilOp, + _pass_op: StencilOp, + _depth_fail_op: StencilOp, + _compare_op: CompareOp, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_stencil_op))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOp\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_op + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterizer_discard_enable: unsafe { + unsafe extern "system" fn cmd_set_rasterizer_discard_enable( + _command_buffer: CommandBuffer, + _rasterizer_discard_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterizer_discard_enable) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizerDiscardEnable\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterizer_discard_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bias_enable: unsafe { + unsafe extern "system" fn cmd_set_depth_bias_enable( + _command_buffer: CommandBuffer, + _depth_bias_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bias_enable) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnable\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_restart_enable: unsafe { + unsafe extern "system" fn cmd_set_primitive_restart_enable( + _command_buffer: CommandBuffer, + _primitive_restart_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_restart_enable) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveRestartEnable\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_restart_enable + } else { + ::std::mem::transmute(val) + } + }, + get_device_buffer_memory_requirements: unsafe { + unsafe extern "system" fn get_device_buffer_memory_requirements( + _device: Device, + _p_info: *const DeviceBufferMemoryRequirements, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_buffer_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceBufferMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_buffer_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_memory_requirements: unsafe { + unsafe extern "system" fn get_device_image_memory_requirements( + _device: Device, + _p_info: *const DeviceImageMemoryRequirements, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_sparse_memory_requirements: unsafe { + unsafe extern "system" fn get_device_image_sparse_memory_requirements( + _device: Device, + _p_info: *const DeviceImageMemoryRequirements, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_sparse_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageSparseMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_sparse_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + } + } +} diff --git a/third_party/rust/ash/src/vk/macros.rs b/third_party/rust/ash/src/vk/macros.rs new file mode 100644 index 0000000000..e986be3125 --- /dev/null +++ b/third_party/rust/ash/src/vk/macros.rs @@ -0,0 +1,162 @@ +#[macro_export] +macro_rules! vk_bitflags_wrapped { + ($ name : ident , $ flag_type : ty) => { + impl Default for $name { + fn default() -> Self { + Self(0) + } + } + impl $name { + #[inline] + pub const fn empty() -> Self { + Self(0) + } + #[inline] + pub const fn from_raw(x: $flag_type) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> $flag_type { + self.0 + } + #[inline] + pub const fn is_empty(self) -> bool { + self.0 == Self::empty().0 + } + #[inline] + pub const fn intersects(self, other: Self) -> bool { + !Self(self.0 & other.0).is_empty() + } + #[doc = r" Returns whether `other` is a subset of `self`"] + #[inline] + pub const fn contains(self, other: Self) -> bool { + self.0 & other.0 == other.0 + } + } + impl ::std::ops::BitOr for $name { + type Output = Self; + #[inline] + fn bitor(self, rhs: Self) -> Self { + Self(self.0 | rhs.0) + } + } + impl ::std::ops::BitOrAssign for $name { + #[inline] + fn bitor_assign(&mut self, rhs: Self) { + *self = *self | rhs + } + } + impl ::std::ops::BitAnd for $name { + type Output = Self; + #[inline] + fn bitand(self, rhs: Self) -> Self { + Self(self.0 & rhs.0) + } + } + impl ::std::ops::BitAndAssign for $name { + #[inline] + fn bitand_assign(&mut self, rhs: Self) { + *self = *self & rhs + } + } + impl ::std::ops::BitXor for $name { + type Output = Self; + #[inline] + fn bitxor(self, rhs: Self) -> Self { + Self(self.0 ^ rhs.0) + } + } + impl ::std::ops::BitXorAssign for $name { + #[inline] + fn bitxor_assign(&mut self, rhs: Self) { + *self = *self ^ rhs + } + } + impl ::std::ops::Not for $name { + type Output = Self; + #[inline] + fn not(self) -> Self { + Self(!self.0) + } + } + }; +} +#[macro_export] +macro_rules! handle_nondispatchable { + ($ name : ident , $ ty : ident) => { + handle_nondispatchable!($name, $ty, doc = ""); + }; + ($ name : ident , $ ty : ident , $ doc_link : meta) => { + #[repr(transparent)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] + #[$doc_link] + pub struct $name(u64); + impl Handle for $name { + const TYPE: ObjectType = ObjectType::$ty; + fn as_raw(self) -> u64 { + self.0 + } + fn from_raw(x: u64) -> Self { + Self(x) + } + } + impl $name { + pub const fn null() -> Self { + Self(0) + } + } + impl fmt::Pointer for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "0x{:x}", self.0) + } + } + impl fmt::Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "0x{:x}", self.0) + } + } + }; +} +#[macro_export] +macro_rules! define_handle { + ($ name : ident , $ ty : ident) => { + define_handle!($name, $ty, doc = ""); + }; + ($ name : ident , $ ty : ident , $ doc_link : meta) => { + #[repr(transparent)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] + #[$doc_link] + pub struct $name(*mut u8); + impl Default for $name { + fn default() -> Self { + Self::null() + } + } + impl Handle for $name { + const TYPE: ObjectType = ObjectType::$ty; + fn as_raw(self) -> u64 { + self.0 as u64 + } + fn from_raw(x: u64) -> Self { + Self(x as _) + } + } + unsafe impl Send for $name {} + unsafe impl Sync for $name {} + impl $name { + pub const fn null() -> Self { + Self(::std::ptr::null_mut()) + } + } + impl fmt::Pointer for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Pointer::fmt(&self.0, f) + } + } + impl fmt::Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.0, f) + } + } + }; +} diff --git a/third_party/rust/ash/src/vk/native.rs b/third_party/rust/ash/src/vk/native.rs new file mode 100644 index 0000000000..02edfba5c8 --- /dev/null +++ b/third_party/rust/ash/src/vk/native.rs @@ -0,0 +1,8998 @@ +/* automatically generated by rust-bindgen 0.61.0 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + *byte |= mask; + } else { + *byte &= !mask; + } + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } +} +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME: + StdVideoH264ChromaFormatIdc = 0; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_420: + StdVideoH264ChromaFormatIdc = 1; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_422: + StdVideoH264ChromaFormatIdc = 2; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_444: + StdVideoH264ChromaFormatIdc = 3; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID: + StdVideoH264ChromaFormatIdc = 2147483647; +pub type StdVideoH264ChromaFormatIdc = ::std::os::raw::c_uint; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_BASELINE: StdVideoH264ProfileIdc = 66; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_MAIN: StdVideoH264ProfileIdc = 77; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH: StdVideoH264ProfileIdc = 100; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE: + StdVideoH264ProfileIdc = 244; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_INVALID: StdVideoH264ProfileIdc = + 2147483647; +pub type StdVideoH264ProfileIdc = ::std::os::raw::c_uint; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_0: StdVideoH264LevelIdc = 0; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_1: StdVideoH264LevelIdc = 1; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_2: StdVideoH264LevelIdc = 2; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_3: StdVideoH264LevelIdc = 3; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_0: StdVideoH264LevelIdc = 4; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_1: StdVideoH264LevelIdc = 5; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_2: StdVideoH264LevelIdc = 6; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_0: StdVideoH264LevelIdc = 7; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_1: StdVideoH264LevelIdc = 8; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_2: StdVideoH264LevelIdc = 9; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_0: StdVideoH264LevelIdc = 10; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_1: StdVideoH264LevelIdc = 11; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_2: StdVideoH264LevelIdc = 12; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_0: StdVideoH264LevelIdc = 13; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_1: StdVideoH264LevelIdc = 14; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_2: StdVideoH264LevelIdc = 15; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_0: StdVideoH264LevelIdc = 16; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_1: StdVideoH264LevelIdc = 17; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_2: StdVideoH264LevelIdc = 18; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_INVALID: StdVideoH264LevelIdc = 2147483647; +pub type StdVideoH264LevelIdc = ::std::os::raw::c_uint; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_0: StdVideoH264PocType = 0; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_1: StdVideoH264PocType = 1; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_2: StdVideoH264PocType = 2; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_INVALID: StdVideoH264PocType = 2147483647; +pub type StdVideoH264PocType = ::std::os::raw::c_uint; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED: + StdVideoH264AspectRatioIdc = 0; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE: + StdVideoH264AspectRatioIdc = 1; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11: + StdVideoH264AspectRatioIdc = 2; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11: + StdVideoH264AspectRatioIdc = 3; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11: + StdVideoH264AspectRatioIdc = 4; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33: + StdVideoH264AspectRatioIdc = 5; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11: + StdVideoH264AspectRatioIdc = 6; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11: + StdVideoH264AspectRatioIdc = 7; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11: + StdVideoH264AspectRatioIdc = 8; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33: + StdVideoH264AspectRatioIdc = 9; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11: + StdVideoH264AspectRatioIdc = 10; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11: + StdVideoH264AspectRatioIdc = 11; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33: + StdVideoH264AspectRatioIdc = 12; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99: + StdVideoH264AspectRatioIdc = 13; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3: + StdVideoH264AspectRatioIdc = 14; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2: + StdVideoH264AspectRatioIdc = 15; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1: + StdVideoH264AspectRatioIdc = 16; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR: + StdVideoH264AspectRatioIdc = 255; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID: + StdVideoH264AspectRatioIdc = 2147483647; +pub type StdVideoH264AspectRatioIdc = ::std::os::raw::c_uint; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT: + StdVideoH264WeightedBipredIdc = 0; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT: + StdVideoH264WeightedBipredIdc = 1; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT: + StdVideoH264WeightedBipredIdc = 2; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID: + StdVideoH264WeightedBipredIdc = 2147483647; +pub type StdVideoH264WeightedBipredIdc = ::std::os::raw::c_uint; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT : StdVideoH264ModificationOfPicNumsIdc = 0 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD : StdVideoH264ModificationOfPicNumsIdc = 1 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM : StdVideoH264ModificationOfPicNumsIdc = 2 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END: + StdVideoH264ModificationOfPicNumsIdc = 3; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID : StdVideoH264ModificationOfPicNumsIdc = 2147483647 ; +pub type StdVideoH264ModificationOfPicNumsIdc = ::std::os::raw::c_uint; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END: + StdVideoH264MemMgmtControlOp = 0; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM: + StdVideoH264MemMgmtControlOp = 1; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM: + StdVideoH264MemMgmtControlOp = 2; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM: + StdVideoH264MemMgmtControlOp = 3; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX : StdVideoH264MemMgmtControlOp = 4 ; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL: + StdVideoH264MemMgmtControlOp = 5; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM : StdVideoH264MemMgmtControlOp = 6 ; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID: + StdVideoH264MemMgmtControlOp = 2147483647; +pub type StdVideoH264MemMgmtControlOp = ::std::os::raw::c_uint; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_0: StdVideoH264CabacInitIdc = 0; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_1: StdVideoH264CabacInitIdc = 1; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_2: StdVideoH264CabacInitIdc = 2; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_INVALID: StdVideoH264CabacInitIdc = + 2147483647; +pub type StdVideoH264CabacInitIdc = ::std::os::raw::c_uint; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED : StdVideoH264DisableDeblockingFilterIdc = 0 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED : StdVideoH264DisableDeblockingFilterIdc = 1 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL : StdVideoH264DisableDeblockingFilterIdc = 2 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID : StdVideoH264DisableDeblockingFilterIdc = 2147483647 ; +pub type StdVideoH264DisableDeblockingFilterIdc = ::std::os::raw::c_uint; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_P: StdVideoH264SliceType = 0; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_B: StdVideoH264SliceType = 1; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_I: StdVideoH264SliceType = 2; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_INVALID: StdVideoH264SliceType = + 2147483647; +pub type StdVideoH264SliceType = ::std::os::raw::c_uint; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_P: StdVideoH264PictureType = 0; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_B: StdVideoH264PictureType = 1; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_I: StdVideoH264PictureType = 2; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_IDR: StdVideoH264PictureType = 5; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_INVALID: StdVideoH264PictureType = + 2147483647; +pub type StdVideoH264PictureType = ::std::os::raw::c_uint; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264SpsVuiFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[test] +fn bindgen_test_layout_StdVideoH264SpsVuiFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH264SpsVuiFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH264SpsVuiFlags)) + ); +} +impl StdVideoH264SpsVuiFlags { + #[inline] + pub fn aspect_ratio_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn overscan_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_overscan_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn overscan_appropriate_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_overscan_appropriate_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn video_signal_type_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_video_signal_type_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn video_full_range_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_video_full_range_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn color_description_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_color_description_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn chroma_loc_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_chroma_loc_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn timing_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_timing_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn fixed_frame_rate_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_fixed_frame_rate_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn bitstream_restriction_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_bitstream_restriction_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn nal_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_nal_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn vcl_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_vcl_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + aspect_ratio_info_present_flag: u32, + overscan_info_present_flag: u32, + overscan_appropriate_flag: u32, + video_signal_type_present_flag: u32, + video_full_range_flag: u32, + color_description_present_flag: u32, + chroma_loc_info_present_flag: u32, + timing_info_present_flag: u32, + fixed_frame_rate_flag: u32, + bitstream_restriction_flag: u32, + nal_hrd_parameters_present_flag: u32, + vcl_hrd_parameters_present_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let aspect_ratio_info_present_flag: u32 = + unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) }; + aspect_ratio_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let overscan_info_present_flag: u32 = + unsafe { ::std::mem::transmute(overscan_info_present_flag) }; + overscan_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let overscan_appropriate_flag: u32 = + unsafe { ::std::mem::transmute(overscan_appropriate_flag) }; + overscan_appropriate_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let video_signal_type_present_flag: u32 = + unsafe { ::std::mem::transmute(video_signal_type_present_flag) }; + video_signal_type_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let video_full_range_flag: u32 = + unsafe { ::std::mem::transmute(video_full_range_flag) }; + video_full_range_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let color_description_present_flag: u32 = + unsafe { ::std::mem::transmute(color_description_present_flag) }; + color_description_present_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let chroma_loc_info_present_flag: u32 = + unsafe { ::std::mem::transmute(chroma_loc_info_present_flag) }; + chroma_loc_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let timing_info_present_flag: u32 = + unsafe { ::std::mem::transmute(timing_info_present_flag) }; + timing_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let fixed_frame_rate_flag: u32 = + unsafe { ::std::mem::transmute(fixed_frame_rate_flag) }; + fixed_frame_rate_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let bitstream_restriction_flag: u32 = + unsafe { ::std::mem::transmute(bitstream_restriction_flag) }; + bitstream_restriction_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let nal_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(nal_hrd_parameters_present_flag) }; + nal_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let vcl_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vcl_hrd_parameters_present_flag) }; + vcl_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264HrdParameters { + pub cpb_cnt_minus1: u8, + pub bit_rate_scale: u8, + pub cpb_size_scale: u8, + pub reserved1: u8, + pub bit_rate_value_minus1: [u32; 32usize], + pub cpb_size_value_minus1: [u32; 32usize], + pub cbr_flag: [u8; 32usize], + pub initial_cpb_removal_delay_length_minus1: u32, + pub cpb_removal_delay_length_minus1: u32, + pub dpb_output_delay_length_minus1: u32, + pub time_offset_length: u32, +} +#[test] +fn bindgen_test_layout_StdVideoH264HrdParameters() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 308usize, + concat!("Size of: ", stringify!(StdVideoH264HrdParameters)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH264HrdParameters)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cpb_cnt_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(bit_rate_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cpb_size_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 3usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(bit_rate_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize }, + 132usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cpb_size_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize }, + 260usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cbr_flag) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize + - ptr as usize + }, + 292usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(initial_cpb_removal_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).cpb_removal_delay_length_minus1) as usize - ptr as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cpb_removal_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize + }, + 300usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(dpb_output_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).time_offset_length) as usize - ptr as usize }, + 304usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(time_offset_length) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264SequenceParameterSetVui { + pub flags: StdVideoH264SpsVuiFlags, + pub aspect_ratio_idc: StdVideoH264AspectRatioIdc, + pub sar_width: u16, + pub sar_height: u16, + pub video_format: u8, + pub colour_primaries: u8, + pub transfer_characteristics: u8, + pub matrix_coefficients: u8, + pub num_units_in_tick: u32, + pub time_scale: u32, + pub max_num_reorder_frames: u8, + pub max_dec_frame_buffering: u8, + pub chroma_sample_loc_type_top_field: u8, + pub chroma_sample_loc_type_bottom_field: u8, + pub reserved1: u32, + pub pHrdParameters: *const StdVideoH264HrdParameters, +} +#[test] +fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSetVui)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoH264SequenceParameterSetVui) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(aspect_ratio_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(sar_width) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(sar_height) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(video_format) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(colour_primaries) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(transfer_characteristics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).matrix_coefficients) as usize - ptr as usize }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(matrix_coefficients) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_units_in_tick) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(num_units_in_tick) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).time_scale) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(time_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_frames) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(max_num_reorder_frames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_dec_frame_buffering) as usize - ptr as usize }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(max_dec_frame_buffering) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize + }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_top_field) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize + }, + 27usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_bottom_field) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(pHrdParameters) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264SpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[test] +fn bindgen_test_layout_StdVideoH264SpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH264SpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH264SpsFlags)) + ); +} +impl StdVideoH264SpsFlags { + #[inline] + pub fn constraint_set0_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set0_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set1_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set1_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set2_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set2_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set3_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set3_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set4_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set4_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set5_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set5_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn direct_8x8_inference_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_direct_8x8_inference_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn mb_adaptive_frame_field_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn frame_mbs_only_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_frame_mbs_only_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn delta_pic_order_always_zero_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn separate_colour_plane_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_separate_colour_plane_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn gaps_in_frame_num_value_allowed_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_gaps_in_frame_num_value_allowed_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn qpprime_y_zero_transform_bypass_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_qpprime_y_zero_transform_bypass_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn frame_cropping_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_frame_cropping_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn seq_scaling_matrix_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + constraint_set0_flag: u32, + constraint_set1_flag: u32, + constraint_set2_flag: u32, + constraint_set3_flag: u32, + constraint_set4_flag: u32, + constraint_set5_flag: u32, + direct_8x8_inference_flag: u32, + mb_adaptive_frame_field_flag: u32, + frame_mbs_only_flag: u32, + delta_pic_order_always_zero_flag: u32, + separate_colour_plane_flag: u32, + gaps_in_frame_num_value_allowed_flag: u32, + qpprime_y_zero_transform_bypass_flag: u32, + frame_cropping_flag: u32, + seq_scaling_matrix_present_flag: u32, + vui_parameters_present_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let constraint_set0_flag: u32 = unsafe { ::std::mem::transmute(constraint_set0_flag) }; + constraint_set0_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let constraint_set1_flag: u32 = unsafe { ::std::mem::transmute(constraint_set1_flag) }; + constraint_set1_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let constraint_set2_flag: u32 = unsafe { ::std::mem::transmute(constraint_set2_flag) }; + constraint_set2_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let constraint_set3_flag: u32 = unsafe { ::std::mem::transmute(constraint_set3_flag) }; + constraint_set3_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let constraint_set4_flag: u32 = unsafe { ::std::mem::transmute(constraint_set4_flag) }; + constraint_set4_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let constraint_set5_flag: u32 = unsafe { ::std::mem::transmute(constraint_set5_flag) }; + constraint_set5_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let direct_8x8_inference_flag: u32 = + unsafe { ::std::mem::transmute(direct_8x8_inference_flag) }; + direct_8x8_inference_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let mb_adaptive_frame_field_flag: u32 = + unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) }; + mb_adaptive_frame_field_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) }; + frame_mbs_only_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let delta_pic_order_always_zero_flag: u32 = + unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) }; + delta_pic_order_always_zero_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let separate_colour_plane_flag: u32 = + unsafe { ::std::mem::transmute(separate_colour_plane_flag) }; + separate_colour_plane_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let gaps_in_frame_num_value_allowed_flag: u32 = + unsafe { ::std::mem::transmute(gaps_in_frame_num_value_allowed_flag) }; + gaps_in_frame_num_value_allowed_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let qpprime_y_zero_transform_bypass_flag: u32 = + unsafe { ::std::mem::transmute(qpprime_y_zero_transform_bypass_flag) }; + qpprime_y_zero_transform_bypass_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let frame_cropping_flag: u32 = unsafe { ::std::mem::transmute(frame_cropping_flag) }; + frame_cropping_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let seq_scaling_matrix_present_flag: u32 = + unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) }; + seq_scaling_matrix_present_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let vui_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vui_parameters_present_flag) }; + vui_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264ScalingLists { + pub scaling_list_present_mask: u16, + pub use_default_scaling_matrix_mask: u16, + pub ScalingList4x4: [[u8; 16usize]; 6usize], + pub ScalingList8x8: [[u8; 64usize]; 6usize], +} +#[test] +fn bindgen_test_layout_StdVideoH264ScalingLists() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 484usize, + concat!("Size of: ", stringify!(StdVideoH264ScalingLists)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!("Alignment of ", stringify!(StdVideoH264ScalingLists)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).scaling_list_present_mask) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264ScalingLists), + "::", + stringify!(scaling_list_present_mask) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).use_default_scaling_matrix_mask) as usize - ptr as usize + }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264ScalingLists), + "::", + stringify!(use_default_scaling_matrix_mask) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264ScalingLists), + "::", + stringify!(ScalingList4x4) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264ScalingLists), + "::", + stringify!(ScalingList8x8) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264SequenceParameterSet { + pub flags: StdVideoH264SpsFlags, + pub profile_idc: StdVideoH264ProfileIdc, + pub level_idc: StdVideoH264LevelIdc, + pub chroma_format_idc: StdVideoH264ChromaFormatIdc, + pub seq_parameter_set_id: u8, + pub bit_depth_luma_minus8: u8, + pub bit_depth_chroma_minus8: u8, + pub log2_max_frame_num_minus4: u8, + pub pic_order_cnt_type: StdVideoH264PocType, + pub offset_for_non_ref_pic: i32, + pub offset_for_top_to_bottom_field: i32, + pub log2_max_pic_order_cnt_lsb_minus4: u8, + pub num_ref_frames_in_pic_order_cnt_cycle: u8, + pub max_num_ref_frames: u8, + pub reserved1: u8, + pub pic_width_in_mbs_minus1: u32, + pub pic_height_in_map_units_minus1: u32, + pub frame_crop_left_offset: u32, + pub frame_crop_right_offset: u32, + pub frame_crop_top_offset: u32, + pub frame_crop_bottom_offset: u32, + pub reserved2: u32, + pub pOffsetForRefFrame: *const i32, + pub pScalingLists: *const StdVideoH264ScalingLists, + pub pSequenceParameterSetVui: *const StdVideoH264SequenceParameterSetVui, +} +#[test] +fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoH264SequenceParameterSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).profile_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(profile_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).level_idc) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(level_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(chroma_format_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(bit_depth_luma_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(bit_depth_chroma_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).log2_max_frame_num_minus4) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(log2_max_frame_num_minus4) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_order_cnt_type) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pic_order_cnt_type) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).offset_for_non_ref_pic) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(offset_for_non_ref_pic) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).offset_for_top_to_bottom_field) as usize - ptr as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(offset_for_top_to_bottom_field) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(log2_max_pic_order_cnt_lsb_minus4) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_frames_in_pic_order_cnt_cycle) as usize + - ptr as usize + }, + 33usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(num_ref_frames_in_pic_order_cnt_cycle) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_num_ref_frames) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(max_num_ref_frames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_mbs_minus1) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pic_width_in_mbs_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pic_height_in_map_units_minus1) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pic_height_in_map_units_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_left_offset) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(frame_crop_left_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_right_offset) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(frame_crop_right_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_top_offset) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(frame_crop_top_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_bottom_offset) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(frame_crop_bottom_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pOffsetForRefFrame) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pOffsetForRefFrame) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pScalingLists) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pSequenceParameterSetVui) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264PpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH264PpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH264PpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH264PpsFlags)) + ); +} +impl StdVideoH264PpsFlags { + #[inline] + pub fn transform_8x8_mode_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_transform_8x8_mode_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn redundant_pic_cnt_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn constrained_intra_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_constrained_intra_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn deblocking_filter_control_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn weighted_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_weighted_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn bottom_field_pic_order_in_frame_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_bottom_field_pic_order_in_frame_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn entropy_coding_mode_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_entropy_coding_mode_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn pic_scaling_matrix_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + transform_8x8_mode_flag: u32, + redundant_pic_cnt_present_flag: u32, + constrained_intra_pred_flag: u32, + deblocking_filter_control_present_flag: u32, + weighted_pred_flag: u32, + bottom_field_pic_order_in_frame_present_flag: u32, + entropy_coding_mode_flag: u32, + pic_scaling_matrix_present_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let transform_8x8_mode_flag: u32 = + unsafe { ::std::mem::transmute(transform_8x8_mode_flag) }; + transform_8x8_mode_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let redundant_pic_cnt_present_flag: u32 = + unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) }; + redundant_pic_cnt_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let constrained_intra_pred_flag: u32 = + unsafe { ::std::mem::transmute(constrained_intra_pred_flag) }; + constrained_intra_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let deblocking_filter_control_present_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) }; + deblocking_filter_control_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) }; + weighted_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let bottom_field_pic_order_in_frame_present_flag: u32 = + unsafe { ::std::mem::transmute(bottom_field_pic_order_in_frame_present_flag) }; + bottom_field_pic_order_in_frame_present_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let entropy_coding_mode_flag: u32 = + unsafe { ::std::mem::transmute(entropy_coding_mode_flag) }; + entropy_coding_mode_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let pic_scaling_matrix_present_flag: u32 = + unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) }; + pic_scaling_matrix_present_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264PictureParameterSet { + pub flags: StdVideoH264PpsFlags, + pub seq_parameter_set_id: u8, + pub pic_parameter_set_id: u8, + pub num_ref_idx_l0_default_active_minus1: u8, + pub num_ref_idx_l1_default_active_minus1: u8, + pub weighted_bipred_idc: StdVideoH264WeightedBipredIdc, + pub pic_init_qp_minus26: i8, + pub pic_init_qs_minus26: i8, + pub chroma_qp_index_offset: i8, + pub second_chroma_qp_index_offset: i8, + pub pScalingLists: *const StdVideoH264ScalingLists, +} +#[test] +fn bindgen_test_layout_StdVideoH264PictureParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(StdVideoH264PictureParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoH264PictureParameterSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize + - ptr as usize + }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(num_ref_idx_l0_default_active_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize + - ptr as usize + }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(num_ref_idx_l1_default_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).weighted_bipred_idc) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(weighted_bipred_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_init_qp_minus26) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(pic_init_qp_minus26) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_init_qs_minus26) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(pic_init_qs_minus26) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_qp_index_offset) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(chroma_qp_index_offset) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).second_chroma_qp_index_offset) as usize - ptr as usize + }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(second_chroma_qp_index_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(pScalingLists) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH264PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH264PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoDecodeH264PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoDecodeH264PictureInfoFlags) + ) + ); +} +impl StdVideoDecodeH264PictureInfoFlags { + #[inline] + pub fn field_pic_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_field_pic_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_intra(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_intra(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn IdrPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_IdrPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn bottom_field_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bottom_field_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn complementary_field_pair(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_complementary_field_pair(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + field_pic_flag: u32, + is_intra: u32, + IdrPicFlag: u32, + bottom_field_flag: u32, + is_reference: u32, + complementary_field_pair: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let field_pic_flag: u32 = unsafe { ::std::mem::transmute(field_pic_flag) }; + field_pic_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let is_intra: u32 = unsafe { ::std::mem::transmute(is_intra) }; + is_intra as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) }; + IdrPicFlag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bottom_field_flag: u32 = unsafe { ::std::mem::transmute(bottom_field_flag) }; + bottom_field_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let is_reference: u32 = unsafe { ::std::mem::transmute(is_reference) }; + is_reference as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let complementary_field_pair: u32 = + unsafe { ::std::mem::transmute(complementary_field_pair) }; + complementary_field_pair as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH264PictureInfo { + pub flags: StdVideoDecodeH264PictureInfoFlags, + pub seq_parameter_set_id: u8, + pub pic_parameter_set_id: u8, + pub reserved1: u8, + pub reserved2: u8, + pub frame_num: u16, + pub idr_pic_id: u16, + pub PicOrderCnt: [i32; 2usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(StdVideoDecodeH264PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoDecodeH264PictureInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(frame_num) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(idr_pic_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(PicOrderCnt) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH264ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoDecodeH264ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoDecodeH264ReferenceInfoFlags) + ) + ); +} +impl StdVideoDecodeH264ReferenceInfoFlags { + #[inline] + pub fn top_field_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_top_field_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn bottom_field_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bottom_field_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_non_existing(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_non_existing(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + top_field_flag: u32, + bottom_field_flag: u32, + used_for_long_term_reference: u32, + is_non_existing: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let top_field_flag: u32 = unsafe { ::std::mem::transmute(top_field_flag) }; + top_field_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bottom_field_flag: u32 = unsafe { ::std::mem::transmute(bottom_field_flag) }; + bottom_field_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let is_non_existing: u32 = unsafe { ::std::mem::transmute(is_non_existing) }; + is_non_existing as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH264ReferenceInfo { + pub flags: StdVideoDecodeH264ReferenceInfoFlags, + pub FrameNum: u16, + pub reserved: u16, + pub PicOrderCnt: [i32; 2usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(StdVideoDecodeH264ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoDecodeH264ReferenceInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(FrameNum) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(reserved) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(PicOrderCnt) + ) + ); +} +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME: + StdVideoH265ChromaFormatIdc = 0; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_420: + StdVideoH265ChromaFormatIdc = 1; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_422: + StdVideoH265ChromaFormatIdc = 2; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_444: + StdVideoH265ChromaFormatIdc = 3; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID: + StdVideoH265ChromaFormatIdc = 2147483647; +pub type StdVideoH265ChromaFormatIdc = ::std::os::raw::c_uint; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN: StdVideoH265ProfileIdc = 1; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_10: StdVideoH265ProfileIdc = 2; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE: + StdVideoH265ProfileIdc = 3; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: + StdVideoH265ProfileIdc = 4; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdVideoH265ProfileIdc = + 9; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_INVALID: StdVideoH265ProfileIdc = + 2147483647; +pub type StdVideoH265ProfileIdc = ::std::os::raw::c_uint; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_1_0: StdVideoH265LevelIdc = 0; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_0: StdVideoH265LevelIdc = 1; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_1: StdVideoH265LevelIdc = 2; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_0: StdVideoH265LevelIdc = 3; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_1: StdVideoH265LevelIdc = 4; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_0: StdVideoH265LevelIdc = 5; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_1: StdVideoH265LevelIdc = 6; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_0: StdVideoH265LevelIdc = 7; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_1: StdVideoH265LevelIdc = 8; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_2: StdVideoH265LevelIdc = 9; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_0: StdVideoH265LevelIdc = 10; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_1: StdVideoH265LevelIdc = 11; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_2: StdVideoH265LevelIdc = 12; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_INVALID: StdVideoH265LevelIdc = 2147483647; +pub type StdVideoH265LevelIdc = ::std::os::raw::c_uint; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_B: StdVideoH265SliceType = 0; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_P: StdVideoH265SliceType = 1; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_I: StdVideoH265SliceType = 2; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_INVALID: StdVideoH265SliceType = + 2147483647; +pub type StdVideoH265SliceType = ::std::os::raw::c_uint; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_P: StdVideoH265PictureType = 0; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_B: StdVideoH265PictureType = 1; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_I: StdVideoH265PictureType = 2; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265PictureType = 3; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType = + 2147483647; +pub type StdVideoH265PictureType = ::std::os::raw::c_uint; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED: + StdVideoH265AspectRatioIdc = 0; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE: + StdVideoH265AspectRatioIdc = 1; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11: + StdVideoH265AspectRatioIdc = 2; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11: + StdVideoH265AspectRatioIdc = 3; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11: + StdVideoH265AspectRatioIdc = 4; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33: + StdVideoH265AspectRatioIdc = 5; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11: + StdVideoH265AspectRatioIdc = 6; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11: + StdVideoH265AspectRatioIdc = 7; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11: + StdVideoH265AspectRatioIdc = 8; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33: + StdVideoH265AspectRatioIdc = 9; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11: + StdVideoH265AspectRatioIdc = 10; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11: + StdVideoH265AspectRatioIdc = 11; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33: + StdVideoH265AspectRatioIdc = 12; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99: + StdVideoH265AspectRatioIdc = 13; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3: + StdVideoH265AspectRatioIdc = 14; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2: + StdVideoH265AspectRatioIdc = 15; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1: + StdVideoH265AspectRatioIdc = 16; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR: + StdVideoH265AspectRatioIdc = 255; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID: + StdVideoH265AspectRatioIdc = 2147483647; +pub type StdVideoH265AspectRatioIdc = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265DecPicBufMgr { + pub max_latency_increase_plus1: [u32; 7usize], + pub max_dec_pic_buffering_minus1: [u8; 7usize], + pub max_num_reorder_pics: [u8; 7usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265DecPicBufMgr() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 44usize, + concat!("Size of: ", stringify!(StdVideoH265DecPicBufMgr)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265DecPicBufMgr)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_latency_increase_plus1) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265DecPicBufMgr), + "::", + stringify!(max_latency_increase_plus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).max_dec_pic_buffering_minus1) as usize - ptr as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265DecPicBufMgr), + "::", + stringify!(max_dec_pic_buffering_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_pics) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265DecPicBufMgr), + "::", + stringify!(max_num_reorder_pics) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SubLayerHrdParameters { + pub bit_rate_value_minus1: [u32; 32usize], + pub cpb_size_value_minus1: [u32; 32usize], + pub cpb_size_du_value_minus1: [u32; 32usize], + pub bit_rate_du_value_minus1: [u32; 32usize], + pub cbr_flag: u32, +} +#[test] +fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 516usize, + concat!("Size of: ", stringify!(StdVideoH265SubLayerHrdParameters)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265SubLayerHrdParameters) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(bit_rate_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(cpb_size_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_du_value_minus1) as usize - ptr as usize }, + 256usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(cpb_size_du_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_du_value_minus1) as usize - ptr as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(bit_rate_du_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(cbr_flag) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265HrdFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout_StdVideoH265HrdFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265HrdFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265HrdFlags)) + ); +} +impl StdVideoH265HrdFlags { + #[inline] + pub fn nal_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_nal_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn vcl_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_vcl_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn sub_pic_hrd_params_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_sub_pic_hrd_params_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn sub_pic_cpb_params_in_pic_timing_sei_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_sub_pic_cpb_params_in_pic_timing_sei_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn fixed_pic_rate_general_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) } + } + #[inline] + pub fn set_fixed_pic_rate_general_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 8u8, val as u64) + } + } + #[inline] + pub fn fixed_pic_rate_within_cvs_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) } + } + #[inline] + pub fn set_fixed_pic_rate_within_cvs_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 8u8, val as u64) + } + } + #[inline] + pub fn low_delay_hrd_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 8u8) as u32) } + } + #[inline] + pub fn set_low_delay_hrd_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 8u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + nal_hrd_parameters_present_flag: u32, + vcl_hrd_parameters_present_flag: u32, + sub_pic_hrd_params_present_flag: u32, + sub_pic_cpb_params_in_pic_timing_sei_flag: u32, + fixed_pic_rate_general_flag: u32, + fixed_pic_rate_within_cvs_flag: u32, + low_delay_hrd_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let nal_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(nal_hrd_parameters_present_flag) }; + nal_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let vcl_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vcl_hrd_parameters_present_flag) }; + vcl_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let sub_pic_hrd_params_present_flag: u32 = + unsafe { ::std::mem::transmute(sub_pic_hrd_params_present_flag) }; + sub_pic_hrd_params_present_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let sub_pic_cpb_params_in_pic_timing_sei_flag: u32 = + unsafe { ::std::mem::transmute(sub_pic_cpb_params_in_pic_timing_sei_flag) }; + sub_pic_cpb_params_in_pic_timing_sei_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 8u8, { + let fixed_pic_rate_general_flag: u32 = + unsafe { ::std::mem::transmute(fixed_pic_rate_general_flag) }; + fixed_pic_rate_general_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 8u8, { + let fixed_pic_rate_within_cvs_flag: u32 = + unsafe { ::std::mem::transmute(fixed_pic_rate_within_cvs_flag) }; + fixed_pic_rate_within_cvs_flag as u64 + }); + __bindgen_bitfield_unit.set(20usize, 8u8, { + let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) }; + low_delay_hrd_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265HrdParameters { + pub flags: StdVideoH265HrdFlags, + pub tick_divisor_minus2: u8, + pub du_cpb_removal_delay_increment_length_minus1: u8, + pub dpb_output_delay_du_length_minus1: u8, + pub bit_rate_scale: u8, + pub cpb_size_scale: u8, + pub cpb_size_du_scale: u8, + pub initial_cpb_removal_delay_length_minus1: u8, + pub au_cpb_removal_delay_length_minus1: u8, + pub dpb_output_delay_length_minus1: u8, + pub cpb_cnt_minus1: [u8; 7usize], + pub elemental_duration_in_tc_minus1: [u16; 7usize], + pub reserved: [u16; 3usize], + pub pSubLayerHrdParametersNal: *const StdVideoH265SubLayerHrdParameters, + pub pSubLayerHrdParametersVcl: *const StdVideoH265SubLayerHrdParameters, +} +#[test] +fn bindgen_test_layout_StdVideoH265HrdParameters() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(StdVideoH265HrdParameters)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoH265HrdParameters)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).tick_divisor_minus2) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(tick_divisor_minus2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).du_cpb_removal_delay_increment_length_minus1) as usize + - ptr as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(du_cpb_removal_delay_increment_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).dpb_output_delay_du_length_minus1) as usize - ptr as usize + }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(dpb_output_delay_du_length_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(bit_rate_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(cpb_size_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_du_scale) as usize - ptr as usize }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(cpb_size_du_scale) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize + - ptr as usize + }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(initial_cpb_removal_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).au_cpb_removal_delay_length_minus1) as usize - ptr as usize + }, + 11usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(au_cpb_removal_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(dpb_output_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(cpb_cnt_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).elemental_duration_in_tc_minus1) as usize - ptr as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(elemental_duration_in_tc_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(reserved) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersNal) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(pSubLayerHrdParametersNal) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersVcl) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(pSubLayerHrdParametersVcl) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265VpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265VpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265VpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265VpsFlags)) + ); +} +impl StdVideoH265VpsFlags { + #[inline] + pub fn vps_temporal_id_nesting_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_vps_temporal_id_nesting_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn vps_sub_layer_ordering_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_vps_sub_layer_ordering_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn vps_timing_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_vps_timing_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn vps_poc_proportional_to_timing_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_vps_poc_proportional_to_timing_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + vps_temporal_id_nesting_flag: u32, + vps_sub_layer_ordering_info_present_flag: u32, + vps_timing_info_present_flag: u32, + vps_poc_proportional_to_timing_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let vps_temporal_id_nesting_flag: u32 = + unsafe { ::std::mem::transmute(vps_temporal_id_nesting_flag) }; + vps_temporal_id_nesting_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let vps_sub_layer_ordering_info_present_flag: u32 = + unsafe { ::std::mem::transmute(vps_sub_layer_ordering_info_present_flag) }; + vps_sub_layer_ordering_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let vps_timing_info_present_flag: u32 = + unsafe { ::std::mem::transmute(vps_timing_info_present_flag) }; + vps_timing_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let vps_poc_proportional_to_timing_flag: u32 = + unsafe { ::std::mem::transmute(vps_poc_proportional_to_timing_flag) }; + vps_poc_proportional_to_timing_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ProfileTierLevelFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ProfileTierLevelFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevelFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265ProfileTierLevelFlags) + ) + ); +} +impl StdVideoH265ProfileTierLevelFlags { + #[inline] + pub fn general_tier_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_tier_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn general_progressive_source_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_progressive_source_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn general_interlaced_source_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_interlaced_source_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn general_non_packed_constraint_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_non_packed_constraint_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn general_frame_only_constraint_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_frame_only_constraint_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + general_tier_flag: u32, + general_progressive_source_flag: u32, + general_interlaced_source_flag: u32, + general_non_packed_constraint_flag: u32, + general_frame_only_constraint_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let general_tier_flag: u32 = unsafe { ::std::mem::transmute(general_tier_flag) }; + general_tier_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let general_progressive_source_flag: u32 = + unsafe { ::std::mem::transmute(general_progressive_source_flag) }; + general_progressive_source_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let general_interlaced_source_flag: u32 = + unsafe { ::std::mem::transmute(general_interlaced_source_flag) }; + general_interlaced_source_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let general_non_packed_constraint_flag: u32 = + unsafe { ::std::mem::transmute(general_non_packed_constraint_flag) }; + general_non_packed_constraint_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let general_frame_only_constraint_flag: u32 = + unsafe { ::std::mem::transmute(general_frame_only_constraint_flag) }; + general_frame_only_constraint_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ProfileTierLevel { + pub flags: StdVideoH265ProfileTierLevelFlags, + pub general_profile_idc: StdVideoH265ProfileIdc, + pub general_level_idc: StdVideoH265LevelIdc, +} +#[test] +fn bindgen_test_layout_StdVideoH265ProfileTierLevel() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevel)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265ProfileTierLevel)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).general_profile_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(general_profile_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).general_level_idc) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(general_level_idc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265VideoParameterSet { + pub flags: StdVideoH265VpsFlags, + pub vps_video_parameter_set_id: u8, + pub vps_max_sub_layers_minus1: u8, + pub reserved1: u8, + pub reserved2: u8, + pub vps_num_units_in_tick: u32, + pub vps_time_scale: u32, + pub vps_num_ticks_poc_diff_one_minus1: u32, + pub reserved3: u32, + pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, + pub pHrdParameters: *const StdVideoH265HrdParameters, + pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel, +} +#[test] +fn bindgen_test_layout_StdVideoH265VideoParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(StdVideoH265VideoParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoH265VideoParameterSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vps_video_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vps_max_sub_layers_minus1) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_max_sub_layers_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vps_num_units_in_tick) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_num_units_in_tick) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vps_time_scale) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_time_scale) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).vps_num_ticks_poc_diff_one_minus1) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_num_ticks_poc_diff_one_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(pDecPicBufMgr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(pHrdParameters) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(pProfileTierLevel) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ScalingLists { + pub ScalingList4x4: [[u8; 16usize]; 6usize], + pub ScalingList8x8: [[u8; 64usize]; 6usize], + pub ScalingList16x16: [[u8; 64usize]; 6usize], + pub ScalingList32x32: [[u8; 64usize]; 2usize], + pub ScalingListDCCoef16x16: [u8; 6usize], + pub ScalingListDCCoef32x32: [u8; 2usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ScalingLists() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 1000usize, + concat!("Size of: ", stringify!(StdVideoH265ScalingLists)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(StdVideoH265ScalingLists)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingList4x4) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingList8x8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList16x16) as usize - ptr as usize }, + 480usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingList16x16) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList32x32) as usize - ptr as usize }, + 864usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingList32x32) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingListDCCoef16x16) as usize - ptr as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingListDCCoef16x16) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingListDCCoef32x32) as usize - ptr as usize }, + 998usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingListDCCoef32x32) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SpsVuiFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + pub __bindgen_padding_0: u8, +} +#[test] +fn bindgen_test_layout_StdVideoH265SpsVuiFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265SpsVuiFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265SpsVuiFlags)) + ); +} +impl StdVideoH265SpsVuiFlags { + #[inline] + pub fn aspect_ratio_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn overscan_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_overscan_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn overscan_appropriate_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_overscan_appropriate_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn video_signal_type_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_video_signal_type_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn video_full_range_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_video_full_range_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn colour_description_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_colour_description_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn chroma_loc_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_chroma_loc_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn neutral_chroma_indication_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_neutral_chroma_indication_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn field_seq_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_field_seq_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn frame_field_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_frame_field_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn default_display_window_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_default_display_window_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_timing_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_timing_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_poc_proportional_to_timing_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_poc_proportional_to_timing_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn bitstream_restriction_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_bitstream_restriction_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn tiles_fixed_structure_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_tiles_fixed_structure_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn motion_vectors_over_pic_boundaries_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_motion_vectors_over_pic_boundaries_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub fn restricted_ref_pic_lists_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_restricted_ref_pic_lists_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + aspect_ratio_info_present_flag: u32, + overscan_info_present_flag: u32, + overscan_appropriate_flag: u32, + video_signal_type_present_flag: u32, + video_full_range_flag: u32, + colour_description_present_flag: u32, + chroma_loc_info_present_flag: u32, + neutral_chroma_indication_flag: u32, + field_seq_flag: u32, + frame_field_info_present_flag: u32, + default_display_window_flag: u32, + vui_timing_info_present_flag: u32, + vui_poc_proportional_to_timing_flag: u32, + vui_hrd_parameters_present_flag: u32, + bitstream_restriction_flag: u32, + tiles_fixed_structure_flag: u32, + motion_vectors_over_pic_boundaries_flag: u32, + restricted_ref_pic_lists_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let aspect_ratio_info_present_flag: u32 = + unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) }; + aspect_ratio_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let overscan_info_present_flag: u32 = + unsafe { ::std::mem::transmute(overscan_info_present_flag) }; + overscan_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let overscan_appropriate_flag: u32 = + unsafe { ::std::mem::transmute(overscan_appropriate_flag) }; + overscan_appropriate_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let video_signal_type_present_flag: u32 = + unsafe { ::std::mem::transmute(video_signal_type_present_flag) }; + video_signal_type_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let video_full_range_flag: u32 = + unsafe { ::std::mem::transmute(video_full_range_flag) }; + video_full_range_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let colour_description_present_flag: u32 = + unsafe { ::std::mem::transmute(colour_description_present_flag) }; + colour_description_present_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let chroma_loc_info_present_flag: u32 = + unsafe { ::std::mem::transmute(chroma_loc_info_present_flag) }; + chroma_loc_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let neutral_chroma_indication_flag: u32 = + unsafe { ::std::mem::transmute(neutral_chroma_indication_flag) }; + neutral_chroma_indication_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let field_seq_flag: u32 = unsafe { ::std::mem::transmute(field_seq_flag) }; + field_seq_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let frame_field_info_present_flag: u32 = + unsafe { ::std::mem::transmute(frame_field_info_present_flag) }; + frame_field_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let default_display_window_flag: u32 = + unsafe { ::std::mem::transmute(default_display_window_flag) }; + default_display_window_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let vui_timing_info_present_flag: u32 = + unsafe { ::std::mem::transmute(vui_timing_info_present_flag) }; + vui_timing_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let vui_poc_proportional_to_timing_flag: u32 = + unsafe { ::std::mem::transmute(vui_poc_proportional_to_timing_flag) }; + vui_poc_proportional_to_timing_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let vui_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vui_hrd_parameters_present_flag) }; + vui_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let bitstream_restriction_flag: u32 = + unsafe { ::std::mem::transmute(bitstream_restriction_flag) }; + bitstream_restriction_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let tiles_fixed_structure_flag: u32 = + unsafe { ::std::mem::transmute(tiles_fixed_structure_flag) }; + tiles_fixed_structure_flag as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let motion_vectors_over_pic_boundaries_flag: u32 = + unsafe { ::std::mem::transmute(motion_vectors_over_pic_boundaries_flag) }; + motion_vectors_over_pic_boundaries_flag as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let restricted_ref_pic_lists_flag: u32 = + unsafe { ::std::mem::transmute(restricted_ref_pic_lists_flag) }; + restricted_ref_pic_lists_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SequenceParameterSetVui { + pub flags: StdVideoH265SpsVuiFlags, + pub aspect_ratio_idc: StdVideoH265AspectRatioIdc, + pub sar_width: u16, + pub sar_height: u16, + pub video_format: u8, + pub colour_primaries: u8, + pub transfer_characteristics: u8, + pub matrix_coeffs: u8, + pub chroma_sample_loc_type_top_field: u8, + pub chroma_sample_loc_type_bottom_field: u8, + pub reserved1: u8, + pub reserved2: u8, + pub def_disp_win_left_offset: u16, + pub def_disp_win_right_offset: u16, + pub def_disp_win_top_offset: u16, + pub def_disp_win_bottom_offset: u16, + pub vui_num_units_in_tick: u32, + pub vui_time_scale: u32, + pub vui_num_ticks_poc_diff_one_minus1: u32, + pub min_spatial_segmentation_idc: u16, + pub reserved3: u16, + pub max_bytes_per_pic_denom: u8, + pub max_bits_per_min_cu_denom: u8, + pub log2_max_mv_length_horizontal: u8, + pub log2_max_mv_length_vertical: u8, + pub pHrdParameters: *const StdVideoH265HrdParameters, +} +#[test] +fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSetVui)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265SequenceParameterSetVui) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(aspect_ratio_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(sar_width) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(sar_height) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(video_format) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(colour_primaries) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(transfer_characteristics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).matrix_coeffs) as usize - ptr as usize }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(matrix_coeffs) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_top_field) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize + }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_bottom_field) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_left_offset) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(def_disp_win_left_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_right_offset) as usize - ptr as usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(def_disp_win_right_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_top_offset) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(def_disp_win_top_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_bottom_offset) as usize - ptr as usize }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(def_disp_win_bottom_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vui_num_units_in_tick) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(vui_num_units_in_tick) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vui_time_scale) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(vui_time_scale) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).vui_num_ticks_poc_diff_one_minus1) as usize - ptr as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(vui_num_ticks_poc_diff_one_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).min_spatial_segmentation_idc) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(min_spatial_segmentation_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 42usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_bytes_per_pic_denom) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(max_bytes_per_pic_denom) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_bits_per_min_cu_denom) as usize - ptr as usize }, + 45usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(max_bits_per_min_cu_denom) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_mv_length_horizontal) as usize - ptr as usize + }, + 46usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(log2_max_mv_length_horizontal) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).log2_max_mv_length_vertical) as usize - ptr as usize }, + 47usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(log2_max_mv_length_vertical) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(pHrdParameters) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265PredictorPaletteEntries { + pub PredictorPaletteEntries: [[u16; 128usize]; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265PredictorPaletteEntries() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 768usize, + concat!("Size of: ", stringify!(StdVideoH265PredictorPaletteEntries)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265PredictorPaletteEntries) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PredictorPaletteEntries) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PredictorPaletteEntries), + "::", + stringify!(PredictorPaletteEntries) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout_StdVideoH265SpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265SpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265SpsFlags)) + ); +} +impl StdVideoH265SpsFlags { + #[inline] + pub fn sps_temporal_id_nesting_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_temporal_id_nesting_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn separate_colour_plane_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_separate_colour_plane_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn conformance_window_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_conformance_window_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_sub_layer_ordering_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_sub_layer_ordering_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn scaling_list_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_scaling_list_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_scaling_list_data_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_scaling_list_data_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn amp_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_amp_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn sample_adaptive_offset_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_sample_adaptive_offset_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn pcm_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_pcm_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn pcm_loop_filter_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_pcm_loop_filter_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn long_term_ref_pics_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_long_term_ref_pics_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_temporal_mvp_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_temporal_mvp_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn strong_intra_smoothing_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_strong_intra_smoothing_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_extension_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_extension_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_range_extension_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_range_extension_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn transform_skip_rotation_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_transform_skip_rotation_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub fn transform_skip_context_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_transform_skip_context_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub fn implicit_rdpcm_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_implicit_rdpcm_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub fn explicit_rdpcm_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_explicit_rdpcm_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub fn extended_precision_processing_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_extended_precision_processing_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub fn intra_smoothing_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_intra_smoothing_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub fn high_precision_offsets_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_high_precision_offsets_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub fn persistent_rice_adaptation_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_persistent_rice_adaptation_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub fn cabac_bypass_alignment_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_cabac_bypass_alignment_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_scc_extension_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_scc_extension_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub fn palette_mode_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_palette_mode_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_palette_predictor_initializers_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_palette_predictor_initializers_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + sps_temporal_id_nesting_flag: u32, + separate_colour_plane_flag: u32, + conformance_window_flag: u32, + sps_sub_layer_ordering_info_present_flag: u32, + scaling_list_enabled_flag: u32, + sps_scaling_list_data_present_flag: u32, + amp_enabled_flag: u32, + sample_adaptive_offset_enabled_flag: u32, + pcm_enabled_flag: u32, + pcm_loop_filter_disabled_flag: u32, + long_term_ref_pics_present_flag: u32, + sps_temporal_mvp_enabled_flag: u32, + strong_intra_smoothing_enabled_flag: u32, + vui_parameters_present_flag: u32, + sps_extension_present_flag: u32, + sps_range_extension_flag: u32, + transform_skip_rotation_enabled_flag: u32, + transform_skip_context_enabled_flag: u32, + implicit_rdpcm_enabled_flag: u32, + explicit_rdpcm_enabled_flag: u32, + extended_precision_processing_flag: u32, + intra_smoothing_disabled_flag: u32, + high_precision_offsets_enabled_flag: u32, + persistent_rice_adaptation_enabled_flag: u32, + cabac_bypass_alignment_enabled_flag: u32, + sps_scc_extension_flag: u32, + sps_curr_pic_ref_enabled_flag: u32, + palette_mode_enabled_flag: u32, + sps_palette_predictor_initializers_present_flag: u32, + intra_boundary_filtering_disabled_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let sps_temporal_id_nesting_flag: u32 = + unsafe { ::std::mem::transmute(sps_temporal_id_nesting_flag) }; + sps_temporal_id_nesting_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let separate_colour_plane_flag: u32 = + unsafe { ::std::mem::transmute(separate_colour_plane_flag) }; + separate_colour_plane_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let conformance_window_flag: u32 = + unsafe { ::std::mem::transmute(conformance_window_flag) }; + conformance_window_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let sps_sub_layer_ordering_info_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_sub_layer_ordering_info_present_flag) }; + sps_sub_layer_ordering_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let scaling_list_enabled_flag: u32 = + unsafe { ::std::mem::transmute(scaling_list_enabled_flag) }; + scaling_list_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let sps_scaling_list_data_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_scaling_list_data_present_flag) }; + sps_scaling_list_data_present_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let amp_enabled_flag: u32 = unsafe { ::std::mem::transmute(amp_enabled_flag) }; + amp_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let sample_adaptive_offset_enabled_flag: u32 = + unsafe { ::std::mem::transmute(sample_adaptive_offset_enabled_flag) }; + sample_adaptive_offset_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let pcm_enabled_flag: u32 = unsafe { ::std::mem::transmute(pcm_enabled_flag) }; + pcm_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let pcm_loop_filter_disabled_flag: u32 = + unsafe { ::std::mem::transmute(pcm_loop_filter_disabled_flag) }; + pcm_loop_filter_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let long_term_ref_pics_present_flag: u32 = + unsafe { ::std::mem::transmute(long_term_ref_pics_present_flag) }; + long_term_ref_pics_present_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let sps_temporal_mvp_enabled_flag: u32 = + unsafe { ::std::mem::transmute(sps_temporal_mvp_enabled_flag) }; + sps_temporal_mvp_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let strong_intra_smoothing_enabled_flag: u32 = + unsafe { ::std::mem::transmute(strong_intra_smoothing_enabled_flag) }; + strong_intra_smoothing_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let vui_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vui_parameters_present_flag) }; + vui_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let sps_extension_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_extension_present_flag) }; + sps_extension_present_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let sps_range_extension_flag: u32 = + unsafe { ::std::mem::transmute(sps_range_extension_flag) }; + sps_range_extension_flag as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let transform_skip_rotation_enabled_flag: u32 = + unsafe { ::std::mem::transmute(transform_skip_rotation_enabled_flag) }; + transform_skip_rotation_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let transform_skip_context_enabled_flag: u32 = + unsafe { ::std::mem::transmute(transform_skip_context_enabled_flag) }; + transform_skip_context_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let implicit_rdpcm_enabled_flag: u32 = + unsafe { ::std::mem::transmute(implicit_rdpcm_enabled_flag) }; + implicit_rdpcm_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let explicit_rdpcm_enabled_flag: u32 = + unsafe { ::std::mem::transmute(explicit_rdpcm_enabled_flag) }; + explicit_rdpcm_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let extended_precision_processing_flag: u32 = + unsafe { ::std::mem::transmute(extended_precision_processing_flag) }; + extended_precision_processing_flag as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let intra_smoothing_disabled_flag: u32 = + unsafe { ::std::mem::transmute(intra_smoothing_disabled_flag) }; + intra_smoothing_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let high_precision_offsets_enabled_flag: u32 = + unsafe { ::std::mem::transmute(high_precision_offsets_enabled_flag) }; + high_precision_offsets_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let persistent_rice_adaptation_enabled_flag: u32 = + unsafe { ::std::mem::transmute(persistent_rice_adaptation_enabled_flag) }; + persistent_rice_adaptation_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let cabac_bypass_alignment_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cabac_bypass_alignment_enabled_flag) }; + cabac_bypass_alignment_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let sps_scc_extension_flag: u32 = + unsafe { ::std::mem::transmute(sps_scc_extension_flag) }; + sps_scc_extension_flag as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let sps_curr_pic_ref_enabled_flag: u32 = + unsafe { ::std::mem::transmute(sps_curr_pic_ref_enabled_flag) }; + sps_curr_pic_ref_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let palette_mode_enabled_flag: u32 = + unsafe { ::std::mem::transmute(palette_mode_enabled_flag) }; + palette_mode_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(28usize, 1u8, { + let sps_palette_predictor_initializers_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_palette_predictor_initializers_present_flag) }; + sps_palette_predictor_initializers_present_flag as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let intra_boundary_filtering_disabled_flag: u32 = + unsafe { ::std::mem::transmute(intra_boundary_filtering_disabled_flag) }; + intra_boundary_filtering_disabled_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ShortTermRefPicSetFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ShortTermRefPicSetFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSetFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265ShortTermRefPicSetFlags) + ) + ); +} +impl StdVideoH265ShortTermRefPicSetFlags { + #[inline] + pub fn inter_ref_pic_set_prediction_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_inter_ref_pic_set_prediction_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn delta_rps_sign(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_delta_rps_sign(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + inter_ref_pic_set_prediction_flag: u32, + delta_rps_sign: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let inter_ref_pic_set_prediction_flag: u32 = + unsafe { ::std::mem::transmute(inter_ref_pic_set_prediction_flag) }; + inter_ref_pic_set_prediction_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let delta_rps_sign: u32 = unsafe { ::std::mem::transmute(delta_rps_sign) }; + delta_rps_sign as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ShortTermRefPicSet { + pub flags: StdVideoH265ShortTermRefPicSetFlags, + pub delta_idx_minus1: u32, + pub use_delta_flag: u16, + pub abs_delta_rps_minus1: u16, + pub used_by_curr_pic_flag: u16, + pub used_by_curr_pic_s0_flag: u16, + pub used_by_curr_pic_s1_flag: u16, + pub reserved1: u16, + pub reserved2: u8, + pub reserved3: u8, + pub num_negative_pics: u8, + pub num_positive_pics: u8, + pub delta_poc_s0_minus1: [u16; 16usize], + pub delta_poc_s1_minus1: [u16; 16usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ShortTermRefPicSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265ShortTermRefPicSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_idx_minus1) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_idx_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).use_delta_flag) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(use_delta_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).abs_delta_rps_minus1) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(abs_delta_rps_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_flag) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s0_flag) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_s0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s1_flag) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_s1_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_negative_pics) as usize - ptr as usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(num_negative_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_positive_pics) as usize - ptr as usize }, + 23usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(num_positive_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s0_minus1) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_poc_s0_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s1_minus1) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_poc_s1_minus1) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265LongTermRefPicsSps { + pub used_by_curr_pic_lt_sps_flag: u32, + pub lt_ref_pic_poc_lsb_sps: [u32; 32usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265LongTermRefPicsSps() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 132usize, + concat!("Size of: ", stringify!(StdVideoH265LongTermRefPicsSps)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265LongTermRefPicsSps)) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_sps_flag) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265LongTermRefPicsSps), + "::", + stringify!(used_by_curr_pic_lt_sps_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).lt_ref_pic_poc_lsb_sps) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265LongTermRefPicsSps), + "::", + stringify!(lt_ref_pic_poc_lsb_sps) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SequenceParameterSet { + pub flags: StdVideoH265SpsFlags, + pub chroma_format_idc: StdVideoH265ChromaFormatIdc, + pub pic_width_in_luma_samples: u32, + pub pic_height_in_luma_samples: u32, + pub sps_video_parameter_set_id: u8, + pub sps_max_sub_layers_minus1: u8, + pub sps_seq_parameter_set_id: u8, + pub bit_depth_luma_minus8: u8, + pub bit_depth_chroma_minus8: u8, + pub log2_max_pic_order_cnt_lsb_minus4: u8, + pub log2_min_luma_coding_block_size_minus3: u8, + pub log2_diff_max_min_luma_coding_block_size: u8, + pub log2_min_luma_transform_block_size_minus2: u8, + pub log2_diff_max_min_luma_transform_block_size: u8, + pub max_transform_hierarchy_depth_inter: u8, + pub max_transform_hierarchy_depth_intra: u8, + pub num_short_term_ref_pic_sets: u8, + pub num_long_term_ref_pics_sps: u8, + pub pcm_sample_bit_depth_luma_minus1: u8, + pub pcm_sample_bit_depth_chroma_minus1: u8, + pub log2_min_pcm_luma_coding_block_size_minus3: u8, + pub log2_diff_max_min_pcm_luma_coding_block_size: u8, + pub reserved1: u8, + pub reserved2: u8, + pub palette_max_size: u8, + pub delta_palette_max_predictor_size: u8, + pub motion_vector_resolution_control_idc: u8, + pub sps_num_palette_predictor_initializers_minus1: u8, + pub conf_win_left_offset: u32, + pub conf_win_right_offset: u32, + pub conf_win_top_offset: u32, + pub conf_win_bottom_offset: u32, + pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel, + pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, + pub pScalingLists: *const StdVideoH265ScalingLists, + pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, + pub pLongTermRefPicsSps: *const StdVideoH265LongTermRefPicsSps, + pub pSequenceParameterSetVui: *const StdVideoH265SequenceParameterSetVui, + pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries, +} +#[test] +fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265SequenceParameterSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(chroma_format_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_luma_samples) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pic_width_in_luma_samples) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_height_in_luma_samples) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pic_height_in_luma_samples) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_max_sub_layers_minus1) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_max_sub_layers_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_seq_parameter_set_id) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(bit_depth_luma_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(bit_depth_chroma_minus8) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize + }, + 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_max_pic_order_cnt_lsb_minus4) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_min_luma_coding_block_size_minus3) as usize + - ptr as usize + }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_min_luma_coding_block_size_minus3) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_coding_block_size) as usize + - ptr as usize + }, + 23usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_diff_max_min_luma_coding_block_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_min_luma_transform_block_size_minus2) as usize + - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_min_luma_transform_block_size_minus2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_transform_block_size) as usize + - ptr as usize + }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_diff_max_min_luma_transform_block_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_inter) as usize - ptr as usize + }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(max_transform_hierarchy_depth_inter) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_intra) as usize - ptr as usize + }, + 27usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(max_transform_hierarchy_depth_intra) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(num_short_term_ref_pic_sets) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_ref_pics_sps) as usize - ptr as usize }, + 29usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(num_long_term_ref_pics_sps) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_luma_minus1) as usize - ptr as usize + }, + 30usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pcm_sample_bit_depth_luma_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_chroma_minus1) as usize - ptr as usize + }, + 31usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pcm_sample_bit_depth_chroma_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_min_pcm_luma_coding_block_size_minus3) as usize + - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_min_pcm_luma_coding_block_size_minus3) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_diff_max_min_pcm_luma_coding_block_size) as usize + - ptr as usize + }, + 33usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_diff_max_min_pcm_luma_coding_block_size) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(palette_max_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).delta_palette_max_predictor_size) as usize - ptr as usize + }, + 37usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(delta_palette_max_predictor_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize + - ptr as usize + }, + 38usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(motion_vector_resolution_control_idc) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).sps_num_palette_predictor_initializers_minus1) as usize + - ptr as usize + }, + 39usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_num_palette_predictor_initializers_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).conf_win_left_offset) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(conf_win_left_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).conf_win_right_offset) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(conf_win_right_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).conf_win_top_offset) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(conf_win_top_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).conf_win_bottom_offset) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(conf_win_bottom_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pProfileTierLevel) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pDecPicBufMgr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pScalingLists) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pShortTermRefPicSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPicsSps) as usize - ptr as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pLongTermRefPicsSps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pSequenceParameterSetVui) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pPredictorPaletteEntries) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265PpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout_StdVideoH265PpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265PpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265PpsFlags)) + ); +} +impl StdVideoH265PpsFlags { + #[inline] + pub fn dependent_slice_segments_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_dependent_slice_segments_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn output_flag_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_output_flag_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn sign_data_hiding_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_sign_data_hiding_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn cabac_init_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_cabac_init_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn constrained_intra_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_constrained_intra_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn transform_skip_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_transform_skip_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn cu_qp_delta_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_cu_qp_delta_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_slice_chroma_qp_offsets_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_slice_chroma_qp_offsets_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn weighted_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_weighted_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn weighted_bipred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_weighted_bipred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn transquant_bypass_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_transquant_bypass_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn tiles_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_tiles_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn entropy_coding_sync_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_entropy_coding_sync_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn uniform_spacing_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_uniform_spacing_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn loop_filter_across_tiles_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_loop_filter_across_tiles_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_loop_filter_across_slices_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn deblocking_filter_control_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub fn deblocking_filter_override_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_deblocking_filter_override_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_deblocking_filter_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_deblocking_filter_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_scaling_list_data_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_scaling_list_data_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub fn lists_modification_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_lists_modification_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_segment_header_extension_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_segment_header_extension_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_extension_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_extension_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub fn cross_component_prediction_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_cross_component_prediction_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub fn chroma_qp_offset_list_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_chroma_qp_offset_list_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_curr_pic_ref_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_curr_pic_ref_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub fn residual_adaptive_colour_transform_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_residual_adaptive_colour_transform_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_slice_act_qp_offsets_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_slice_act_qp_offsets_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_palette_predictor_initializers_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_palette_predictor_initializers_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub fn monochrome_palette_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_monochrome_palette_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_range_extension_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_range_extension_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + dependent_slice_segments_enabled_flag: u32, + output_flag_present_flag: u32, + sign_data_hiding_enabled_flag: u32, + cabac_init_present_flag: u32, + constrained_intra_pred_flag: u32, + transform_skip_enabled_flag: u32, + cu_qp_delta_enabled_flag: u32, + pps_slice_chroma_qp_offsets_present_flag: u32, + weighted_pred_flag: u32, + weighted_bipred_flag: u32, + transquant_bypass_enabled_flag: u32, + tiles_enabled_flag: u32, + entropy_coding_sync_enabled_flag: u32, + uniform_spacing_flag: u32, + loop_filter_across_tiles_enabled_flag: u32, + pps_loop_filter_across_slices_enabled_flag: u32, + deblocking_filter_control_present_flag: u32, + deblocking_filter_override_enabled_flag: u32, + pps_deblocking_filter_disabled_flag: u32, + pps_scaling_list_data_present_flag: u32, + lists_modification_present_flag: u32, + slice_segment_header_extension_present_flag: u32, + pps_extension_present_flag: u32, + cross_component_prediction_enabled_flag: u32, + chroma_qp_offset_list_enabled_flag: u32, + pps_curr_pic_ref_enabled_flag: u32, + residual_adaptive_colour_transform_enabled_flag: u32, + pps_slice_act_qp_offsets_present_flag: u32, + pps_palette_predictor_initializers_present_flag: u32, + monochrome_palette_flag: u32, + pps_range_extension_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let dependent_slice_segments_enabled_flag: u32 = + unsafe { ::std::mem::transmute(dependent_slice_segments_enabled_flag) }; + dependent_slice_segments_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let output_flag_present_flag: u32 = + unsafe { ::std::mem::transmute(output_flag_present_flag) }; + output_flag_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let sign_data_hiding_enabled_flag: u32 = + unsafe { ::std::mem::transmute(sign_data_hiding_enabled_flag) }; + sign_data_hiding_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let cabac_init_present_flag: u32 = + unsafe { ::std::mem::transmute(cabac_init_present_flag) }; + cabac_init_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let constrained_intra_pred_flag: u32 = + unsafe { ::std::mem::transmute(constrained_intra_pred_flag) }; + constrained_intra_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let transform_skip_enabled_flag: u32 = + unsafe { ::std::mem::transmute(transform_skip_enabled_flag) }; + transform_skip_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let cu_qp_delta_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cu_qp_delta_enabled_flag) }; + cu_qp_delta_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let pps_slice_chroma_qp_offsets_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_slice_chroma_qp_offsets_present_flag) }; + pps_slice_chroma_qp_offsets_present_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) }; + weighted_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let weighted_bipred_flag: u32 = unsafe { ::std::mem::transmute(weighted_bipred_flag) }; + weighted_bipred_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let transquant_bypass_enabled_flag: u32 = + unsafe { ::std::mem::transmute(transquant_bypass_enabled_flag) }; + transquant_bypass_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let tiles_enabled_flag: u32 = unsafe { ::std::mem::transmute(tiles_enabled_flag) }; + tiles_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let entropy_coding_sync_enabled_flag: u32 = + unsafe { ::std::mem::transmute(entropy_coding_sync_enabled_flag) }; + entropy_coding_sync_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let uniform_spacing_flag: u32 = unsafe { ::std::mem::transmute(uniform_spacing_flag) }; + uniform_spacing_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let loop_filter_across_tiles_enabled_flag: u32 = + unsafe { ::std::mem::transmute(loop_filter_across_tiles_enabled_flag) }; + loop_filter_across_tiles_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let pps_loop_filter_across_slices_enabled_flag: u32 = + unsafe { ::std::mem::transmute(pps_loop_filter_across_slices_enabled_flag) }; + pps_loop_filter_across_slices_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let deblocking_filter_control_present_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) }; + deblocking_filter_control_present_flag as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let deblocking_filter_override_enabled_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_override_enabled_flag) }; + deblocking_filter_override_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let pps_deblocking_filter_disabled_flag: u32 = + unsafe { ::std::mem::transmute(pps_deblocking_filter_disabled_flag) }; + pps_deblocking_filter_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let pps_scaling_list_data_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_scaling_list_data_present_flag) }; + pps_scaling_list_data_present_flag as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let lists_modification_present_flag: u32 = + unsafe { ::std::mem::transmute(lists_modification_present_flag) }; + lists_modification_present_flag as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let slice_segment_header_extension_present_flag: u32 = + unsafe { ::std::mem::transmute(slice_segment_header_extension_present_flag) }; + slice_segment_header_extension_present_flag as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let pps_extension_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_extension_present_flag) }; + pps_extension_present_flag as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let cross_component_prediction_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cross_component_prediction_enabled_flag) }; + cross_component_prediction_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let chroma_qp_offset_list_enabled_flag: u32 = + unsafe { ::std::mem::transmute(chroma_qp_offset_list_enabled_flag) }; + chroma_qp_offset_list_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let pps_curr_pic_ref_enabled_flag: u32 = + unsafe { ::std::mem::transmute(pps_curr_pic_ref_enabled_flag) }; + pps_curr_pic_ref_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let residual_adaptive_colour_transform_enabled_flag: u32 = + unsafe { ::std::mem::transmute(residual_adaptive_colour_transform_enabled_flag) }; + residual_adaptive_colour_transform_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let pps_slice_act_qp_offsets_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_slice_act_qp_offsets_present_flag) }; + pps_slice_act_qp_offsets_present_flag as u64 + }); + __bindgen_bitfield_unit.set(28usize, 1u8, { + let pps_palette_predictor_initializers_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_palette_predictor_initializers_present_flag) }; + pps_palette_predictor_initializers_present_flag as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let monochrome_palette_flag: u32 = + unsafe { ::std::mem::transmute(monochrome_palette_flag) }; + monochrome_palette_flag as u64 + }); + __bindgen_bitfield_unit.set(30usize, 1u8, { + let pps_range_extension_flag: u32 = + unsafe { ::std::mem::transmute(pps_range_extension_flag) }; + pps_range_extension_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265PictureParameterSet { + pub flags: StdVideoH265PpsFlags, + pub pps_pic_parameter_set_id: u8, + pub pps_seq_parameter_set_id: u8, + pub sps_video_parameter_set_id: u8, + pub num_extra_slice_header_bits: u8, + pub num_ref_idx_l0_default_active_minus1: u8, + pub num_ref_idx_l1_default_active_minus1: u8, + pub init_qp_minus26: i8, + pub diff_cu_qp_delta_depth: u8, + pub pps_cb_qp_offset: i8, + pub pps_cr_qp_offset: i8, + pub pps_beta_offset_div2: i8, + pub pps_tc_offset_div2: i8, + pub log2_parallel_merge_level_minus2: u8, + pub log2_max_transform_skip_block_size_minus2: u8, + pub diff_cu_chroma_qp_offset_depth: u8, + pub chroma_qp_offset_list_len_minus1: u8, + pub cb_qp_offset_list: [i8; 6usize], + pub cr_qp_offset_list: [i8; 6usize], + pub log2_sao_offset_scale_luma: u8, + pub log2_sao_offset_scale_chroma: u8, + pub pps_act_y_qp_offset_plus5: i8, + pub pps_act_cb_qp_offset_plus5: i8, + pub pps_act_cr_qp_offset_plus3: i8, + pub pps_num_palette_predictor_initializers: u8, + pub luma_bit_depth_entry_minus8: u8, + pub chroma_bit_depth_entry_minus8: u8, + pub num_tile_columns_minus1: u8, + pub num_tile_rows_minus1: u8, + pub reserved1: u8, + pub reserved2: u8, + pub column_width_minus1: [u16; 19usize], + pub row_height_minus1: [u16; 21usize], + pub reserved3: u32, + pub pScalingLists: *const StdVideoH265ScalingLists, + pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries, +} +#[test] +fn bindgen_test_layout_StdVideoH265PictureParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 144usize, + concat!("Size of: ", stringify!(StdVideoH265PictureParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoH265PictureParameterSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_extra_slice_header_bits) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_extra_slice_header_bits) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize + - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_ref_idx_l0_default_active_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize + - ptr as usize + }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_ref_idx_l1_default_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).init_qp_minus26) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(init_qp_minus26) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).diff_cu_qp_delta_depth) as usize - ptr as usize }, + 11usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(diff_cu_qp_delta_depth) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_cb_qp_offset) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_cb_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_cr_qp_offset) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_cr_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_beta_offset_div2) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_beta_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_tc_offset_div2) as usize - ptr as usize }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_tc_offset_div2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_parallel_merge_level_minus2) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(log2_parallel_merge_level_minus2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_transform_skip_block_size_minus2) as usize + - ptr as usize + }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(log2_max_transform_skip_block_size_minus2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).diff_cu_chroma_qp_offset_depth) as usize - ptr as usize + }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(diff_cu_chroma_qp_offset_depth) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_qp_offset_list_len_minus1) as usize - ptr as usize + }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(chroma_qp_offset_list_len_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cb_qp_offset_list) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(cb_qp_offset_list) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cr_qp_offset_list) as usize - ptr as usize }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(cr_qp_offset_list) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_luma) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(log2_sao_offset_scale_luma) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_chroma) as usize - ptr as usize + }, + 33usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(log2_sao_offset_scale_chroma) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_y_qp_offset_plus5) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_act_y_qp_offset_plus5) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cb_qp_offset_plus5) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_act_cb_qp_offset_plus5) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cr_qp_offset_plus3) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_act_cr_qp_offset_plus3) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializers) as usize + - ptr as usize + }, + 37usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_num_palette_predictor_initializers) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_bit_depth_entry_minus8) as usize - ptr as usize }, + 38usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(luma_bit_depth_entry_minus8) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_bit_depth_entry_minus8) as usize - ptr as usize + }, + 39usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(chroma_bit_depth_entry_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_tile_columns_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize }, + 41usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_tile_rows_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 42usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 43usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).column_width_minus1) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(column_width_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize }, + 82usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(row_height_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 124usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pScalingLists) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pPredictorPaletteEntries) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH265PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH265PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoDecodeH265PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoDecodeH265PictureInfoFlags) + ) + ); +} +impl StdVideoDecodeH265PictureInfoFlags { + #[inline] + pub fn IrapPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_IrapPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn IdrPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_IdrPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn IsReference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_IsReference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + IrapPicFlag: u32, + IdrPicFlag: u32, + IsReference: u32, + short_term_ref_pic_set_sps_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) }; + IrapPicFlag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) }; + IdrPicFlag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let IsReference: u32 = unsafe { ::std::mem::transmute(IsReference) }; + IsReference as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let short_term_ref_pic_set_sps_flag: u32 = + unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) }; + short_term_ref_pic_set_sps_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH265PictureInfo { + pub flags: StdVideoDecodeH265PictureInfoFlags, + pub sps_video_parameter_set_id: u8, + pub pps_seq_parameter_set_id: u8, + pub pps_pic_parameter_set_id: u8, + pub NumDeltaPocsOfRefRpsIdx: u8, + pub PicOrderCntVal: i32, + pub NumBitsForSTRefPicSetInSlice: u16, + pub reserved: u16, + pub RefPicSetStCurrBefore: [u8; 8usize], + pub RefPicSetStCurrAfter: [u8; 8usize], + pub RefPicSetLtCurr: [u8; 8usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(StdVideoDecodeH265PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoDecodeH265PictureInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(pps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(pps_pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).NumDeltaPocsOfRefRpsIdx) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(NumDeltaPocsOfRefRpsIdx) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).NumBitsForSTRefPicSetInSlice) as usize - ptr as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(NumBitsForSTRefPicSetInSlice) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(reserved) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrBefore) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(RefPicSetStCurrBefore) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrAfter) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(RefPicSetStCurrAfter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetLtCurr) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(RefPicSetLtCurr) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH265ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoDecodeH265ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoDecodeH265ReferenceInfoFlags) + ) + ); +} +impl StdVideoDecodeH265ReferenceInfoFlags { + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn unused_for_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_unused_for_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + used_for_long_term_reference: u32, + unused_for_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) }; + unused_for_reference as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH265ReferenceInfo { + pub flags: StdVideoDecodeH265ReferenceInfoFlags, + pub PicOrderCntVal: i32, +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(StdVideoDecodeH265ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoDecodeH265ReferenceInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265ReferenceInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265ReferenceInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264WeightTableFlags { + pub luma_weight_l0_flag: u32, + pub chroma_weight_l0_flag: u32, + pub luma_weight_l1_flag: u32, + pub chroma_weight_l1_flag: u32, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264WeightTableFlags() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTableFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264WeightTableFlags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(luma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(chroma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(luma_weight_l1_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(chroma_weight_l1_flag) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264WeightTable { + pub flags: StdVideoEncodeH264WeightTableFlags, + pub luma_log2_weight_denom: u8, + pub chroma_log2_weight_denom: u8, + pub luma_weight_l0: [i8; 32usize], + pub luma_offset_l0: [i8; 32usize], + pub chroma_weight_l0: [[i8; 2usize]; 32usize], + pub chroma_offset_l0: [[i8; 2usize]; 32usize], + pub luma_weight_l1: [i8; 32usize], + pub luma_offset_l1: [i8; 32usize], + pub chroma_weight_l1: [[i8; 2usize]; 32usize], + pub chroma_offset_l1: [[i8; 2usize]; 32usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264WeightTable() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 404usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTable)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264WeightTable)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_log2_weight_denom) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_weight_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize }, + 50usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_offset_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0) as usize - ptr as usize }, + 82usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_weight_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_offset_l0) as usize - ptr as usize }, + 146usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_offset_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1) as usize - ptr as usize }, + 210usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_weight_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize }, + 242usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_offset_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1) as usize - ptr as usize }, + 274usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_weight_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_offset_l1) as usize - ptr as usize }, + 338usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_offset_l1) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264SliceHeaderFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264SliceHeaderFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeaderFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264SliceHeaderFlags) + ) + ); +} +impl StdVideoEncodeH264SliceHeaderFlags { + #[inline] + pub fn direct_spatial_mv_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_direct_spatial_mv_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn num_ref_idx_active_override_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn no_output_of_prior_pics_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn adaptive_ref_pic_marking_mode_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_adaptive_ref_pic_marking_mode_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn no_prior_references_available_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_prior_references_available_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + direct_spatial_mv_pred_flag: u32, + num_ref_idx_active_override_flag: u32, + no_output_of_prior_pics_flag: u32, + adaptive_ref_pic_marking_mode_flag: u32, + no_prior_references_available_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let direct_spatial_mv_pred_flag: u32 = + unsafe { ::std::mem::transmute(direct_spatial_mv_pred_flag) }; + direct_spatial_mv_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let num_ref_idx_active_override_flag: u32 = + unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) }; + num_ref_idx_active_override_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let no_output_of_prior_pics_flag: u32 = + unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; + no_output_of_prior_pics_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let adaptive_ref_pic_marking_mode_flag: u32 = + unsafe { ::std::mem::transmute(adaptive_ref_pic_marking_mode_flag) }; + adaptive_ref_pic_marking_mode_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let no_prior_references_available_flag: u32 = + unsafe { ::std::mem::transmute(no_prior_references_available_flag) }; + no_prior_references_available_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264PictureInfoFlags) + ) + ); +} +impl StdVideoEncodeH264PictureInfoFlags { + #[inline] + pub fn idr_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_idr_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_reference_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_reference_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + idr_flag: u32, + is_reference_flag: u32, + used_for_long_term_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let idr_flag: u32 = unsafe { ::std::mem::transmute(idr_flag) }; + idr_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) }; + is_reference_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH264ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264ReferenceInfoFlags) + ) + ); +} +impl StdVideoEncodeH264ReferenceInfoFlags { + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + used_for_long_term_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264RefMgmtFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264RefMgmtFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264RefMgmtFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264RefMgmtFlags)) + ); +} +impl StdVideoEncodeH264RefMgmtFlags { + #[inline] + pub fn ref_pic_list_modification_l0_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_l0_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn ref_pic_list_modification_l1_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_l1_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + ref_pic_list_modification_l0_flag: u32, + ref_pic_list_modification_l1_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let ref_pic_list_modification_l0_flag: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_l0_flag) }; + ref_pic_list_modification_l0_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let ref_pic_list_modification_l1_flag: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_l1_flag) }; + ref_pic_list_modification_l1_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264RefListModEntry { + pub modification_of_pic_nums_idc: StdVideoH264ModificationOfPicNumsIdc, + pub abs_diff_pic_num_minus1: u16, + pub long_term_pic_num: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264RefListModEntry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264RefListModEntry) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).modification_of_pic_nums_idc) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefListModEntry), + "::", + stringify!(modification_of_pic_nums_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).abs_diff_pic_num_minus1) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefListModEntry), + "::", + stringify!(abs_diff_pic_num_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefListModEntry), + "::", + stringify!(long_term_pic_num) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264RefPicMarkingEntry { + pub operation: StdVideoH264MemMgmtControlOp, + pub difference_of_pic_nums_minus1: u16, + pub long_term_pic_num: u16, + pub long_term_frame_idx: u16, + pub max_long_term_frame_idx_plus1: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(operation) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).difference_of_pic_nums_minus1) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(difference_of_pic_nums_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(long_term_pic_num) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(long_term_frame_idx) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).max_long_term_frame_idx_plus1) as usize - ptr as usize + }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(max_long_term_frame_idx_plus1) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264RefMemMgmtCtrlOperations { + pub flags: StdVideoEncodeH264RefMgmtFlags, + pub refList0ModOpCount: u8, + pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry, + pub refList1ModOpCount: u8, + pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry, + pub refPicMarkingOpCount: u8, + pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264RefMemMgmtCtrlOperations() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(refList0ModOpCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(pRefList0ModOperations) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(refList1ModOpCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(pRefList1ModOperations) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(refPicMarkingOpCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(pRefPicMarkingOperations) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264PictureInfo { + pub flags: StdVideoEncodeH264PictureInfoFlags, + pub seq_parameter_set_id: u8, + pub pic_parameter_set_id: u8, + pub pictureType: StdVideoH264PictureType, + pub frame_num: u32, + pub PicOrderCnt: i32, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264PictureInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(pictureType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(frame_num) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(PicOrderCnt) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264ReferenceInfo { + pub flags: StdVideoEncodeH264ReferenceInfoFlags, + pub FrameNum: u32, + pub PicOrderCnt: i32, + pub long_term_pic_num: u16, + pub long_term_frame_idx: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264ReferenceInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(FrameNum) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(PicOrderCnt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(long_term_pic_num) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(long_term_frame_idx) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264SliceHeader { + pub flags: StdVideoEncodeH264SliceHeaderFlags, + pub first_mb_in_slice: u32, + pub slice_type: StdVideoH264SliceType, + pub idr_pic_id: u16, + pub num_ref_idx_l0_active_minus1: u8, + pub num_ref_idx_l1_active_minus1: u8, + pub cabac_init_idc: StdVideoH264CabacInitIdc, + pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc, + pub slice_alpha_c0_offset_div2: i8, + pub slice_beta_offset_div2: i8, + pub pWeightTable: *const StdVideoEncodeH264WeightTable, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeader)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264SliceHeader)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).first_mb_in_slice) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(first_mb_in_slice) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(slice_type) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(idr_pic_id) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize + }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(num_ref_idx_l0_active_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize + }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(num_ref_idx_l1_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cabac_init_idc) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(cabac_init_idc) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).disable_deblocking_filter_idc) as usize - ptr as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(disable_deblocking_filter_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_alpha_c0_offset_div2) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(slice_alpha_c0_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(slice_beta_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(pWeightTable) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265WeightTableFlags { + pub luma_weight_l0_flag: u16, + pub chroma_weight_l0_flag: u16, + pub luma_weight_l1_flag: u16, + pub chroma_weight_l1_flag: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265WeightTableFlags() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTableFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265WeightTableFlags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(luma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(chroma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(luma_weight_l1_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(chroma_weight_l1_flag) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265WeightTable { + pub flags: StdVideoEncodeH265WeightTableFlags, + pub luma_log2_weight_denom: u8, + pub delta_chroma_log2_weight_denom: i8, + pub delta_luma_weight_l0: [i8; 15usize], + pub luma_offset_l0: [i8; 15usize], + pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize], + pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize], + pub delta_luma_weight_l1: [i8; 15usize], + pub luma_offset_l1: [i8; 15usize], + pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize], + pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265WeightTable() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 190usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTable)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265WeightTable)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).delta_chroma_log2_weight_denom) as usize - ptr as usize + }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_luma_weight_l0) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_luma_weight_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_offset_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_weight_l0) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_weight_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_offset_l0) as usize - ptr as usize }, + 70usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_offset_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_luma_weight_l1) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_luma_weight_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize }, + 115usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_offset_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_weight_l1) as usize - ptr as usize }, + 130usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_weight_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_offset_l1) as usize - ptr as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_offset_l1) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentHeaderFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags) + ) + ); +} +impl StdVideoEncodeH265SliceSegmentHeaderFlags { + #[inline] + pub fn first_slice_segment_in_pic_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_first_slice_segment_in_pic_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn no_output_of_prior_pics_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn dependent_slice_segment_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_dependent_slice_segment_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn pic_output_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_pic_output_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_temporal_mvp_enable_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_temporal_mvp_enable_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_sao_luma_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_sao_luma_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_sao_chroma_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_sao_chroma_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn num_ref_idx_active_override_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn mvd_l1_zero_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_mvd_l1_zero_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn cabac_init_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_cabac_init_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_cu_chroma_qp_offset_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn deblocking_filter_override_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_deblocking_filter_override_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_deblocking_filter_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_deblocking_filter_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn collocated_from_l0_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_collocated_from_l0_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + first_slice_segment_in_pic_flag: u32, + no_output_of_prior_pics_flag: u32, + dependent_slice_segment_flag: u32, + pic_output_flag: u32, + short_term_ref_pic_set_sps_flag: u32, + slice_temporal_mvp_enable_flag: u32, + slice_sao_luma_flag: u32, + slice_sao_chroma_flag: u32, + num_ref_idx_active_override_flag: u32, + mvd_l1_zero_flag: u32, + cabac_init_flag: u32, + cu_chroma_qp_offset_enabled_flag: u32, + deblocking_filter_override_flag: u32, + slice_deblocking_filter_disabled_flag: u32, + collocated_from_l0_flag: u32, + slice_loop_filter_across_slices_enabled_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let first_slice_segment_in_pic_flag: u32 = + unsafe { ::std::mem::transmute(first_slice_segment_in_pic_flag) }; + first_slice_segment_in_pic_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let no_output_of_prior_pics_flag: u32 = + unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; + no_output_of_prior_pics_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let dependent_slice_segment_flag: u32 = + unsafe { ::std::mem::transmute(dependent_slice_segment_flag) }; + dependent_slice_segment_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let pic_output_flag: u32 = unsafe { ::std::mem::transmute(pic_output_flag) }; + pic_output_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let short_term_ref_pic_set_sps_flag: u32 = + unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) }; + short_term_ref_pic_set_sps_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let slice_temporal_mvp_enable_flag: u32 = + unsafe { ::std::mem::transmute(slice_temporal_mvp_enable_flag) }; + slice_temporal_mvp_enable_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let slice_sao_luma_flag: u32 = unsafe { ::std::mem::transmute(slice_sao_luma_flag) }; + slice_sao_luma_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let slice_sao_chroma_flag: u32 = + unsafe { ::std::mem::transmute(slice_sao_chroma_flag) }; + slice_sao_chroma_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let num_ref_idx_active_override_flag: u32 = + unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) }; + num_ref_idx_active_override_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let mvd_l1_zero_flag: u32 = unsafe { ::std::mem::transmute(mvd_l1_zero_flag) }; + mvd_l1_zero_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let cabac_init_flag: u32 = unsafe { ::std::mem::transmute(cabac_init_flag) }; + cabac_init_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let cu_chroma_qp_offset_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cu_chroma_qp_offset_enabled_flag) }; + cu_chroma_qp_offset_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let deblocking_filter_override_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_override_flag) }; + deblocking_filter_override_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let slice_deblocking_filter_disabled_flag: u32 = + unsafe { ::std::mem::transmute(slice_deblocking_filter_disabled_flag) }; + slice_deblocking_filter_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let collocated_from_l0_flag: u32 = + unsafe { ::std::mem::transmute(collocated_from_l0_flag) }; + collocated_from_l0_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let slice_loop_filter_across_slices_enabled_flag: u32 = + unsafe { ::std::mem::transmute(slice_loop_filter_across_slices_enabled_flag) }; + slice_loop_filter_across_slices_enabled_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics { + pub num_long_term_sps: u8, + pub num_long_term_pics: u8, + pub lt_idx_sps: [u8; 32usize], + pub poc_lsb_lt: [u8; 16usize], + pub used_by_curr_pic_lt_flag: u16, + pub delta_poc_msb_present_flag: [u8; 48usize], + pub delta_poc_msb_cycle_lt: [u8; 48usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 148usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(num_long_term_sps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(num_long_term_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(lt_idx_sps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(poc_lsb_lt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize }, + 50usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(used_by_curr_pic_lt_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(delta_poc_msb_present_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(delta_poc_msb_cycle_lt) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentHeader { + pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags, + pub slice_type: StdVideoH265SliceType, + pub slice_segment_address: u32, + pub short_term_ref_pic_set_idx: u8, + pub collocated_ref_idx: u8, + pub num_ref_idx_l0_active_minus1: u8, + pub num_ref_idx_l1_active_minus1: u8, + pub MaxNumMergeCand: u8, + pub slice_cb_qp_offset: i8, + pub slice_cr_qp_offset: i8, + pub slice_beta_offset_div2: i8, + pub slice_tc_offset_div2: i8, + pub slice_act_y_qp_offset: i8, + pub slice_act_cb_qp_offset: i8, + pub slice_act_cr_qp_offset: i8, + pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, + pub pLongTermRefPics: *const StdVideoEncodeH265SliceSegmentLongTermRefPics, + pub pWeightTable: *const StdVideoEncodeH265WeightTable, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceSegmentHeader) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_type) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_segment_address) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(short_term_ref_pic_set_idx) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(collocated_ref_idx) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize + }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(num_ref_idx_l0_active_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize + }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(num_ref_idx_l1_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(MaxNumMergeCand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_cb_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_cr_qp_offset) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_cr_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_beta_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_tc_offset_div2) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_tc_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_act_y_qp_offset) as usize - ptr as usize }, + 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_act_y_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cb_qp_offset) as usize - ptr as usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_act_cb_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cr_qp_offset) as usize - ptr as usize }, + 23usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_act_cr_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(pShortTermRefPicSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(pLongTermRefPics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(pWeightTable) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceModificationFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceModificationFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceModificationFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceModificationFlags) + ) + ); +} +impl StdVideoEncodeH265ReferenceModificationFlags { + #[inline] + pub fn ref_pic_list_modification_flag_l0(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn ref_pic_list_modification_flag_l1(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + ref_pic_list_modification_flag_l0: u32, + ref_pic_list_modification_flag_l1: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let ref_pic_list_modification_flag_l0: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) }; + ref_pic_list_modification_flag_l0 as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let ref_pic_list_modification_flag_l1: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) }; + ref_pic_list_modification_flag_l1 as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceModifications { + pub flags: StdVideoEncodeH265ReferenceModificationFlags, + pub referenceList0ModificationsCount: u8, + pub pReferenceList0Modifications: *const u8, + pub referenceList1ModificationsCount: u8, + pub pReferenceList1Modifications: *const u8, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceModifications() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceModifications) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceModifications) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).referenceList0ModificationsCount) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(referenceList0ModificationsCount) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pReferenceList0Modifications) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(pReferenceList0Modifications) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).referenceList1ModificationsCount) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(referenceList1ModificationsCount) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pReferenceList1Modifications) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(pReferenceList1Modifications) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265PictureInfoFlags) + ) + ); +} +impl StdVideoEncodeH265PictureInfoFlags { + #[inline] + pub fn is_reference_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_reference_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn IrapPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_IrapPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn long_term_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_long_term_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn discardable_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_discardable_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn cross_layer_bla_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_cross_layer_bla_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + is_reference_flag: u32, + IrapPicFlag: u32, + long_term_flag: u32, + discardable_flag: u32, + cross_layer_bla_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) }; + is_reference_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) }; + IrapPicFlag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let long_term_flag: u32 = unsafe { ::std::mem::transmute(long_term_flag) }; + long_term_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let discardable_flag: u32 = unsafe { ::std::mem::transmute(discardable_flag) }; + discardable_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let cross_layer_bla_flag: u32 = unsafe { ::std::mem::transmute(cross_layer_bla_flag) }; + cross_layer_bla_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265PictureInfo { + pub flags: StdVideoEncodeH265PictureInfoFlags, + pub PictureType: StdVideoH265PictureType, + pub sps_video_parameter_set_id: u8, + pub pps_seq_parameter_set_id: u8, + pub pps_pic_parameter_set_id: u8, + pub PicOrderCntVal: i32, + pub TemporalId: u8, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(PictureType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pps_pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(TemporalId) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceInfoFlags) + ) + ); +} +impl StdVideoEncodeH265ReferenceInfoFlags { + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn unused_for_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_unused_for_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + used_for_long_term_reference: u32, + unused_for_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) }; + unused_for_reference as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceInfo { + pub flags: StdVideoEncodeH265ReferenceInfoFlags, + pub PicOrderCntVal: i32, + pub TemporalId: u8, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265ReferenceInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(TemporalId) + ) + ); +} diff --git a/third_party/rust/ash/src/vk/platform_types.rs b/third_party/rust/ash/src/vk/platform_types.rs new file mode 100644 index 0000000000..4d6ffe0597 --- /dev/null +++ b/third_party/rust/ash/src/vk/platform_types.rs @@ -0,0 +1,41 @@ +#![allow(non_camel_case_types)] + +use std::os::raw::*; +pub type RROutput = c_ulong; +pub type VisualID = c_uint; +pub type Display = *const c_void; +pub type Window = c_ulong; +pub type xcb_connection_t = c_void; +pub type xcb_window_t = u32; +pub type xcb_visualid_t = u32; +pub type MirConnection = *const c_void; +pub type MirSurface = *const c_void; +pub type HINSTANCE = *const c_void; +pub type HWND = *const c_void; +pub type wl_display = c_void; +pub type wl_surface = c_void; +pub type HANDLE = *mut c_void; +pub type HMONITOR = HANDLE; +pub type DWORD = c_ulong; +pub type LPCWSTR = *const u16; +pub type zx_handle_t = u32; +pub type _screen_context = c_void; +pub type _screen_window = c_void; +pub type SECURITY_ATTRIBUTES = c_void; +// Opaque types +pub type ANativeWindow = c_void; +pub type AHardwareBuffer = c_void; +pub type CAMetalLayer = c_void; +// This definition is behind an NDA with a best effort guess from +// https://github.com/google/gapid/commit/22aafebec4638c6aaa77667096bca30f6e842d95#diff-ab3ab4a7d89b4fc8a344ff4e9332865f268ea1669ee379c1b516a954ecc2e7a6R20-R21 +pub type GgpStreamDescriptor = u32; +pub type GgpFrameToken = u64; +pub type IDirectFB = c_void; +pub type IDirectFBSurface = c_void; +pub type __IOSurface = c_void; +pub type IOSurfaceRef = *mut __IOSurface; +pub type MTLBuffer_id = *mut c_void; +pub type MTLCommandQueue_id = *mut c_void; +pub type MTLDevice_id = *mut c_void; +pub type MTLSharedEvent_id = *mut c_void; +pub type MTLTexture_id = *mut c_void; diff --git a/third_party/rust/ash/src/vk/prelude.rs b/third_party/rust/ash/src/vk/prelude.rs new file mode 100644 index 0000000000..cb2f17718c --- /dev/null +++ b/third_party/rust/ash/src/vk/prelude.rs @@ -0,0 +1,61 @@ +use crate::vk; + +/// Holds 24 bits in the least significant bits of memory, +/// and 8 bytes in the most significant bits of that memory, +/// occupying a single [`u32`] in total. This is commonly used in +/// [acceleration structure instances] such as +/// [`vk::AccelerationStructureInstanceKHR`], +/// [`vk::AccelerationStructureSRTMotionInstanceNV`] and +/// [`vk::AccelerationStructureMatrixMotionInstanceNV`]. +/// +/// [acceleration structure instances]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceKHR.html#_description +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)] +#[repr(transparent)] +pub struct Packed24_8(u32); + +impl Packed24_8 { + pub fn new(low_24: u32, high_8: u8) -> Self { + Self((low_24 & 0x00ff_ffff) | (u32::from(high_8) << 24)) + } + + /// Extracts the least-significant 24 bits (3 bytes) of this integer + pub fn low_24(&self) -> u32 { + self.0 & 0xffffff + } + + /// Extracts the most significant 8 bits (single byte) of this integer + pub fn high_8(&self) -> u8 { + (self.0 >> 24) as u8 + } +} + +impl vk::ColorComponentFlags { + /// Contraction of [`R`][Self::R] | [`G`][Self::G] | [`B`][Self::B] | [`A`][Self::A] + pub const RGBA: Self = Self(Self::R.0 | Self::G.0 | Self::B.0 | Self::A.0); +} + +impl From for vk::Extent3D { + fn from(value: vk::Extent2D) -> Self { + Self { + width: value.width, + height: value.height, + depth: 1, + } + } +} + +impl From for vk::Rect2D { + fn from(extent: vk::Extent2D) -> Self { + Self { + offset: Default::default(), + extent, + } + } +} + +/// Structures implementing this trait are layout-compatible with [`vk::BaseInStructure`] and +/// [`vk::BaseOutStructure`]. Such structures have an `s_type` field indicating its type, which +/// must always match the value of [`TaggedStructure::STRUCTURE_TYPE`]. +pub unsafe trait TaggedStructure { + const STRUCTURE_TYPE: vk::StructureType; +} diff --git a/third_party/rust/ash/tests/constant_size_arrays.rs b/third_party/rust/ash/tests/constant_size_arrays.rs new file mode 100644 index 0000000000..a756f34ac2 --- /dev/null +++ b/third_party/rust/ash/tests/constant_size_arrays.rs @@ -0,0 +1,33 @@ +use ash::vk::{PhysicalDeviceProperties, PipelineColorBlendStateCreateInfo}; + +#[test] +fn assert_struct_field_is_array() { + let pipeline_cache_uuid: [u8; 16] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + + let _ = PhysicalDeviceProperties::builder().pipeline_cache_uuid(pipeline_cache_uuid); + + let _ = PhysicalDeviceProperties { + pipeline_cache_uuid, + ..Default::default() + }; + + let blend_constants: [f32; 4] = [0.0, 0.0, 0.0, 0.0]; + + let _ = PipelineColorBlendStateCreateInfo::builder().blend_constants(blend_constants); + + let _ = PipelineColorBlendStateCreateInfo { + blend_constants, + ..Default::default() + }; +} + +#[test] +#[allow(dead_code)] +fn assert_ffi_array_param_is_pointer() { + // don't run it, just make sure it compiles + unsafe fn dummy(device: &ash::Device, cmd_buffer: ash::vk::CommandBuffer) { + let blend_constants: [f32; 4] = [0.0, 0.0, 0.0, 0.0]; + + device.cmd_set_blend_constants(cmd_buffer, &blend_constants); + } +} diff --git a/third_party/rust/ash/tests/display.rs b/third_party/rust/ash/tests/display.rs new file mode 100644 index 0000000000..f4131fdc7c --- /dev/null +++ b/third_party/rust/ash/tests/display.rs @@ -0,0 +1,17 @@ +use ash::vk; + +#[test] +fn debug_flags() { + assert_eq!( + format!( + "{:?}", + vk::AccessFlags::INDIRECT_COMMAND_READ | vk::AccessFlags::VERTEX_ATTRIBUTE_READ + ), + "INDIRECT_COMMAND_READ | VERTEX_ATTRIBUTE_READ" + ); +} + +#[test] +fn debug_enum() { + assert_eq!(format!("{:?}", vk::ChromaLocation::MIDPOINT), "MIDPOINT"); +} -- cgit v1.2.3