Vendor things

third-party/vendor/ash/Cargo.toml

@@ -0,0 +1,54 @@
+# 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 = "2021"
+rust-version = "1.59.0"
+name = "ash"
+version = "0.37.3+1.3.251"
+authors = [
+    "Maik Klein <maikklein@googlemail.com>",
+    "Benjamin Saunders <ben.e.saunders@gmail.com>",
+    "Marijn Suijten <marijn@traverseresearch.nl>",
+]
+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"
+resolver = "1"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+
+[package.metadata.release]
+no-dev-version = true
+
+[dependencies.libloading]
+version = "0.7"
+optional = true
+
+[features]
+debug = []
+default = [
+    "loaded",
+    "debug",
+]
+linked = []
+loaded = ["libloading"]

third-party/vendor/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.

third-party/vendor/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.

third-party/vendor/ash/README.md

@@ -0,0 +1,290 @@
+# 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)
+[![MSRV](https://img.shields.io/badge/rustc-1.60.0+-ab6000.svg)](https://blog.rust-lang.org/2022/04/07/Rust-1.60.0.html)
+
+## 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<Instance, InstanceError> { .. }
+let instance = entry.create_instance(&create_info, None)
+    .expect("Instance creation error");
+```
+
+
+### `Vec<T>` instead of mutable slices
+
+```rust
+pub fn get_swapchain_images(&self,
+                            swapchain: vk::SwapchainKHR)
+                            -> VkResult<Vec<vk::Image>>;
+let present_images = swapchain_loader.get_swapchain_images_khr(swapchain).unwrap();
+```
+*Note*: Functions don't return `Vec<T>` 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<vk::CommandPool>;
+
+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/<version>` by default. You will need to set the following environment variables when running cargo:
+```sh
+VULKAN_SDK=$HOME/VulkanSDK/<version>/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)

third-party/vendor/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}");
+    }
+}

third-party/vendor/ash/src/entry.rs

@@ -0,0 +1,425 @@
+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<Arc<Library>>,
+}
+
+/// 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 Vulkan functions loaded directly or indirectly from this [`Entry`]
+    /// may be called after it is [dropped][drop()].
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use ash::{vk, Entry};
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// 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<Self, LoadingError> {
+        #[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.
+    ///
+    /// Any Vulkan function acquired directly or indirectly from this [`Entry`] may be called after it
+    /// is [dropped][drop()].
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use ash::{vk, Entry};
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// 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.
+    ///
+    /// No Vulkan functions loaded directly or indirectly from this [`Entry`]
+    /// may be called after it is [dropped][drop()].
+    #[cfg(feature = "loaded")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))]
+    pub unsafe fn load_from(path: impl AsRef<OsStr>) -> Result<Self, LoadingError> {
+        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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceVersion.html>
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// # use ash::{Entry, vk};
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// 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<Option<u32>> {
+        unsafe {
+            let mut api_version = 0;
+            let enumerate_instance_version: Option<vk::PFN_vkEnumerateInstanceVersion> = {
+                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)
+            }
+        }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateInstance.html>
+    ///
+    /// # Safety
+    ///
+    /// The resulting [`Instance`] and any function-pointer objects (e.g. [`Device`][crate::Device]
+    /// and [extensions][crate::extensions]) loaded from it may not be used after this [`Entry`]
+    /// object is dropped, unless it was crated using [`Entry::linked()`].
+    ///
+    /// [`Instance`] does _not_ implement [drop][drop()] semantics and can only be destroyed via
+    /// [`destroy_instance()`][Instance::destroy_instance()].
+    #[inline]
+    pub unsafe fn create_instance(
+        &self,
+        create_info: &vk::InstanceCreateInfo,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<Instance> {
+        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))
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceLayerProperties.html>
+    #[inline]
+    pub fn enumerate_instance_layer_properties(&self) -> VkResult<Vec<vk::LayerProperties>> {
+        unsafe {
+            read_into_uninitialized_vector(|count, data| {
+                (self.entry_fn_1_0.enumerate_instance_layer_properties)(count, data)
+            })
+        }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceExtensionProperties.html>
+    #[inline]
+    pub fn enumerate_instance_extension_properties(
+        &self,
+        layer_name: Option<&CStr>,
+    ) -> VkResult<Vec<vk::ExtensionProperties>> {
+        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,
+                )
+            })
+        }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetInstanceProcAddr.html>
+    #[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"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceVersion.html>
+    ///
+    /// Please use [`try_enumerate_instance_version()`][Self::try_enumerate_instance_version()] instead.
+    #[inline]
+    pub fn enumerate_instance_version(&self) -> VkResult<u32> {
+        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<F>(mut _f: F) -> Result<Self, MissingEntryPoint>
+    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<MissingEntryPoint> for LoadingError {
+        fn from(err: MissingEntryPoint) -> Self {
+            Self::MissingEntryPoint(err)
+        }
+    }
+}
+#[cfg(feature = "loaded")]
+pub use self::loaded::*;

third-party/vendor/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<T>(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<F>(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<T>(
+        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,
+}

third-party/vendor/ash/src/extensions/experimental/mod.rs

@@ -0,0 +1 @@
+pub mod amd;

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_acquire_drm_display.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireDrmDisplayEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDrmDisplayEXT.html>
+    #[inline]
+    pub unsafe fn get_drm_display(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        drm_fd: i32,
+        connector_id: u32,
+    ) -> VkResult<vk::DisplayKHR> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferDeviceAddressEXT.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html>
+    #[inline]
+    pub unsafe fn get_physical_device_calibrateable_time_domains(
+        &self,
+        physical_device: vk::PhysicalDevice,
+    ) -> VkResult<Vec<vk::TimeDomainEXT>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_physical_device_calibrateable_time_domains_ext)(
+                physical_device,
+                count,
+                data,
+            )
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetCalibratedTimestampsEXT.html>
+    ///
+    /// Returns a tuple containing `(timestamps, max_deviation)`
+    #[inline]
+    pub unsafe fn get_calibrated_timestamps(
+        &self,
+        device: vk::Device,
+        info: &[vk::CalibratedTimestampInfoEXT],
+    ) -> VkResult<(Vec<u64>, Vec<u64>)> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDebugMarkerSetObjectNameEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDebugMarkerBeginEXT.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDebugMarkerEndEXT.html>
+    #[inline]
+    pub unsafe fn cmd_debug_marker_end(&self, command_buffer: vk::CommandBuffer) {
+        (self.fp.cmd_debug_marker_end_ext)(command_buffer);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDebugMarkerInsertEXT.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDebugReportCallbackEXT.html>
+    #[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(),
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDebugReportCallbackEXT.html>
+    #[inline]
+    pub unsafe fn create_debug_report_callback(
+        &self,
+        create_info: &vk::DebugReportCallbackCreateInfoEXT,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::DebugReportCallbackEXT> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetDebugUtilsObjectNameEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetDebugUtilsObjectNameEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetDebugUtilsObjectTagEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetDebugUtilsObjectTagEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginDebugUtilsLabelEXT.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndDebugUtilsLabelEXT.html>
+    #[inline]
+    pub unsafe fn cmd_end_debug_utils_label(&self, command_buffer: vk::CommandBuffer) {
+        (self.fp.cmd_end_debug_utils_label_ext)(command_buffer);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdInsertDebugUtilsLabelEXT.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueBeginDebugUtilsLabelEXT.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueEndDebugUtilsLabelEXT.html>
+    #[inline]
+    pub unsafe fn queue_end_debug_utils_label(&self, queue: vk::Queue) {
+        (self.fp.queue_end_debug_utils_label_ext)(queue);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueInsertDebugUtilsLabelEXT.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDebugUtilsMessengerEXT.html>
+    #[inline]
+    pub unsafe fn create_debug_utils_messenger(
+        &self,
+        create_info: &vk::DebugUtilsMessengerCreateInfoEXT,
+        allocator: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::DebugUtilsMessengerEXT> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDebugUtilsMessengerEXT.html>
+    #[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());
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSubmitDebugUtilsMessageEXT.html>
+    #[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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_descriptor_buffer.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorSetLayoutSizeEXT.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindDescriptorBuffersEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCullModeEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetFrontFaceEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveTopologyEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWithCountEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetScissorWithCountEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindVertexBuffers2EXT.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthTestEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthWriteEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthCompareOpEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBoundsTestEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilTestEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilOpEXT.html>
+    #[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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_extended_dynamic_state2.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPatchControlPointsEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizerDiscardEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBiasEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLogicOpEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveRestartEnableEXT.html>
+    #[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
+    }
+}

third-party/vendor/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;
+
+/// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_extended_dynamic_state3.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetTessellationDomainOriginEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClampEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPolygonModeEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizationSamplesEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleMaskEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetAlphaToCoverageEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetAlphaToOneEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLogicOpEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendEquationEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorWriteMaskEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizationStreamEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetConservativeRasterizationModeEXT.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClipEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleLocationsEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendAdvancedEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetProvokingVertexModeEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineRasterizationModeEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineStippleEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWScalingEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportSwizzleNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageToColorEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageToColorLocationNV.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationModeNV.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationTableEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationTableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetShadingRateImageEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageReductionModeNV.html>
+    #[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
+    }
+}

third-party/vendor/ash/src/extensions/ext/full_screen_exclusive.rs

@@ -0,0 +1,111 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_full_screen_exclusive.html>
+#[derive(Clone)]
+pub struct FullScreenExclusive {
+    handle: vk::Device,
+    fp: vk::ExtFullScreenExclusiveFn,
+}
+
+impl FullScreenExclusive {
+    /// # Warning
+    /// [`Instance`] functions cannot be loaded from a [`Device`] and will always panic when called:
+    /// - [`Self::get_physical_device_surface_present_modes2()`]
+    ///
+    /// Load this struct using an [`Instance`] instead via [`Self::new_from_instance()`] if the
+    /// above [`Instance`] function is called. This will be solved in the next breaking `ash`
+    /// release: <https://github.com/ash-rs/ash/issues/727>.
+    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 }
+    }
+
+    /// Loads all functions on the [`Instance`] instead of [`Device`]. This incurs an extra
+    /// dispatch table for [`Device`] functions but also allows the [`Instance`] function to be
+    /// loaded instead of always panicking. See also [`Self::new()`] for more details.
+    ///
+    /// It is okay to pass [`vk::Device::null()`] when this struct is only used to call the
+    /// [`Instance`] function.
+    pub fn new_from_instance(entry: &Entry, instance: &Instance, device: vk::Device) -> Self {
+        let fp = vk::ExtFullScreenExclusiveFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { handle: device, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireFullScreenExclusiveModeEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html>
+    ///
+    /// # Warning
+    ///
+    /// Function will always panic unless this struct is loaded via [`Self::new_from_instance()`].
+    #[inline]
+    pub unsafe fn get_physical_device_surface_present_modes2(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR,
+    ) -> VkResult<Vec<vk::PresentModeKHR>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_physical_device_surface_present_modes2_ext)(
+                physical_device,
+                surface_info,
+                count,
+                data,
+            )
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkReleaseFullScreenExclusiveModeEXT.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html>
+    #[inline]
+    pub unsafe fn get_device_group_surface_present_modes2(
+        &self,
+        surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR,
+    ) -> VkResult<vk::DeviceGroupPresentModeFlagsKHR> {
+        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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_headless_surface.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateHeadlessSurfaceEXT.html>
+    #[inline]
+    pub unsafe fn create_headless_surface(
+        &self,
+        create_info: &vk::HeadlessSurfaceCreateInfoEXT,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_image_compression_control.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSubresourceLayout2EXT.html>
+    #[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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_image_drm_format_modifier.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html>
+    #[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
+    }
+}

third-party/vendor/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;
+
+/// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_mesh_shader.html>
+#[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 }
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksEXT.html>
+    #[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,
+        );
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectEXT.html>
+    ///
+    /// `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,
+        );
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html>
+    ///
+    /// `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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateMetalSurfaceEXT.html>
+    #[inline]
+    pub unsafe fn create_metal_surface(
+        &self,
+        create_info: &vk::MetalSurfaceCreateInfoEXT,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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
+    }
+}

third-party/vendor/ash/src/extensions/ext/mod.rs

@@ -0,0 +1,49 @@
+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::pipeline_properties::PipelineProperties;
+pub use self::private_data::PrivateData;
+pub use self::sample_locations::SampleLocations;
+pub use self::shader_object::ShaderObject;
+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 pipeline_properties;
+mod private_data;
+mod sample_locations;
+mod shader_object;
+mod tooling_info;

third-party/vendor/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()
+    }
+}

third-party/vendor/ash/src/extensions/ext/pipeline_properties.rs

@@ -0,0 +1,52 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_pipeline_properties.html>
+#[derive(Clone)]
+pub struct PipelineProperties {
+    handle: vk::Device,
+    fp: vk::ExtPipelinePropertiesFn,
+}
+
+impl PipelineProperties {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::ExtPipelinePropertiesFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelinePropertiesEXT.html>
+    #[inline]
+    pub unsafe fn get_pipeline_properties(
+        &self,
+        pipeline_info: &vk::PipelineInfoEXT,
+        pipeline_properties: &mut impl vk::GetPipelinePropertiesEXTParamPipelineProperties,
+    ) -> VkResult<()> {
+        (self.fp.get_pipeline_properties_ext)(
+            self.handle,
+            pipeline_info,
+            <*mut _>::cast(pipeline_properties),
+        )
+        .result()
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtPipelinePropertiesFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtPipelinePropertiesFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_private_data.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreatePrivateDataSlotEXT.html>
+    #[inline]
+    pub unsafe fn create_private_data_slot(
+        &self,
+        create_info: &vk::PrivateDataSlotCreateInfoEXT,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::PrivateDataSlotEXT> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyPrivateDataSlotEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetPrivateDataEXT.html>
+    #[inline]
+    pub unsafe fn set_private_data<T: vk::Handle>(
+        &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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPrivateDataEXT.html>
+    #[inline]
+    pub unsafe fn get_private_data<T: vk::Handle>(
+        &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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_sample_locations.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleLocationsEXT.html>
+    #[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
+    }
+}

third-party/vendor/ash/src/extensions/ext/shader_object.rs

@@ -0,0 +1,719 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::RawPtr;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_shader_object.html>
+#[derive(Clone)]
+pub struct ShaderObject {
+    handle: vk::Device,
+    fp: vk::ExtShaderObjectFn,
+}
+
+impl ShaderObject {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::ExtShaderObjectFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateShadersEXT.html>
+    #[inline]
+    pub unsafe fn create_shaders(
+        &self,
+        create_infos: &[vk::ShaderCreateInfoEXT],
+        allocator: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<Vec<vk::ShaderEXT>> {
+        let mut shaders = Vec::with_capacity(create_infos.len());
+        (self.fp.create_shaders_ext)(
+            self.handle,
+            create_infos.len() as u32,
+            create_infos.as_ptr(),
+            allocator.as_raw_ptr(),
+            shaders.as_mut_ptr(),
+        )
+        .result()?;
+        shaders.set_len(create_infos.len());
+        Ok(shaders)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyShaderEXT.html>
+    #[inline]
+    pub unsafe fn destroy_shader(
+        &self,
+        shader: vk::ShaderEXT,
+        allocator: Option<&vk::AllocationCallbacks>,
+    ) {
+        (self.fp.destroy_shader_ext)(self.handle, shader, allocator.as_raw_ptr())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetShaderBinaryDataEXT.html>
+    #[inline]
+    pub unsafe fn get_shader_binary_data(&self, shader: vk::ShaderEXT) -> VkResult<Vec<u8>> {
+        read_into_uninitialized_vector(|count, data: *mut u8| {
+            (self.fp.get_shader_binary_data_ext)(self.handle, shader, count, data.cast())
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindShadersEXT.html>
+    #[inline]
+    pub unsafe fn cmd_bind_shaders(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        stages: &[vk::ShaderStageFlags],
+        shaders: &[vk::ShaderEXT],
+    ) {
+        assert_eq!(stages.len(), shaders.len());
+        (self.fp.cmd_bind_shaders_ext)(
+            command_buffer,
+            stages.len() as u32,
+            stages.as_ptr(),
+            shaders.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetVertexInputEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_vertex_input(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        vertex_binding_descriptions: &[vk::VertexInputBindingDescription2EXT],
+        vertex_attribute_descriptions: &[vk::VertexInputAttributeDescription2EXT],
+    ) {
+        (self.fp.cmd_set_vertex_input_ext)(
+            command_buffer,
+            vertex_binding_descriptions.len() as u32,
+            vertex_binding_descriptions.as_ptr(),
+            vertex_attribute_descriptions.len() as u32,
+            vertex_attribute_descriptions.as_ptr(),
+        )
+    }
+
+    // --- extended_dynamic_state functions ---
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCullModeEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetFrontFaceEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveTopologyEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWithCountEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetScissorWithCountEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindVertexBuffers2EXT.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthTestEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthWriteEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthCompareOpEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBoundsTestEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilTestEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilOpEXT.html>
+    #[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,
+        )
+    }
+
+    // --- extended_dynamic_state2 functions ---
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPatchControlPointsEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizerDiscardEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBiasEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLogicOpEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveRestartEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    // --- extended_dynamic_state3 functions ---
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetTessellationDomainOriginEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClampEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPolygonModeEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizationSamplesEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleMaskEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetAlphaToCoverageEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetAlphaToOneEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLogicOpEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendEquationEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorWriteMaskEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizationStreamEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetConservativeRasterizationModeEXT.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClipEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleLocationsEnableEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendAdvancedEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetProvokingVertexModeEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineRasterizationModeEXT.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineStippleEnableEXT.html>
+    #[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())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWScalingEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportSwizzleNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageToColorEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageToColorLocationNV.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationModeNV.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationTableEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationTableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetShadingRateImageEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageReductionModeNV.html>
+    #[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)
+    }
+
+    pub const fn name() -> &'static CStr {
+        vk::ExtShaderObjectFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtShaderObjectFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html>
+    #[inline]
+    pub unsafe fn get_physical_device_tool_properties(
+        &self,
+        physical_device: vk::PhysicalDevice,
+    ) -> VkResult<Vec<vk::PhysicalDeviceToolPropertiesEXT>> {
+        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
+    }
+}

third-party/vendor/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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateAccelerationStructureKHR.html>
+    #[inline]
+    pub unsafe fn create_acceleration_structure(
+        &self,
+        create_info: &vk::AccelerationStructureCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::AccelerationStructureKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyAccelerationStructureKHR.html>
+    #[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(),
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBuildAccelerationStructuresKHR.html>
+    #[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::<Vec<_>>();
+
+        (self.fp.cmd_build_acceleration_structures_khr)(
+            command_buffer,
+            infos.len() as _,
+            infos.as_ptr(),
+            build_range_infos.as_ptr(),
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html>
+    #[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::<Vec<_>>();
+
+        (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(),
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBuildAccelerationStructuresKHR.html>
+    #[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::<Vec<_>>();
+
+        (self.fp.build_acceleration_structures_khr)(
+            self.handle,
+            deferred_operation,
+            infos.len() as _,
+            infos.as_ptr(),
+            build_range_infos.as_ptr(),
+        )
+        .result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCopyAccelerationStructureKHR.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCopyAccelerationStructureToMemoryKHR.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCopyMemoryToAccelerationStructureKHR.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkWriteAccelerationStructuresPropertiesKHR.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyAccelerationStructureKHR.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureHandleKHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureBuildSizesKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateAndroidSurfaceKHR.html>
+    #[inline]
+    pub unsafe fn create_android_surface(
+        &self,
+        create_info: &vk::AndroidSurfaceCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferDeviceAddressKHR.html>
+    #[inline]
+    pub unsafe fn get_buffer_device_address(
+        &self,
+        info: &vk::BufferDeviceAddressInfoKHR,
+    ) -> vk::DeviceAddress {
+        (self.fp.get_buffer_device_address_khr)(self.handle, info)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferOpaqueCaptureAddressKHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html>
+    #[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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_copy_commands2.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyBuffer2KHR.html>
+    #[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)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyImage2KHR.html>
+    #[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)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyBufferToImage2KHR.html>
+    #[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)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyImageToBuffer2KHR.html>
+    #[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)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBlitImage2KHR.html>
+    #[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)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResolveImage2KHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRenderPass2.html>
+    #[inline]
+    pub unsafe fn create_render_pass2(
+        &self,
+        create_info: &vk::RenderPassCreateInfo2,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::RenderPass> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginRenderPass2.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdNextSubpass2.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndRenderPass2.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDeferredOperationKHR.html>
+    #[inline]
+    pub unsafe fn create_deferred_operation(
+        &self,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::DeferredOperationKHR> {
+        let mut operation = mem::zeroed();
+        (self.fp.create_deferred_operation_khr)(
+            self.handle,
+            allocation_callbacks.as_raw_ptr(),
+            &mut operation,
+        )
+        .result_with_success(operation)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDeferredOperationJoinKHR.html>
+    #[inline]
+    pub unsafe fn deferred_operation_join(
+        &self,
+        operation: vk::DeferredOperationKHR,
+    ) -> VkResult<()> {
+        (self.fp.deferred_operation_join_khr)(self.handle, operation).result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDeferredOperationKHR.html>
+    #[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(),
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeferredOperationResultKHR.html>
+    #[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
+    }
+}

third-party/vendor/ash/src/extensions/khr/device_group.rs

@@ -0,0 +1,193 @@
+#[cfg(doc)]
+use super::Swapchain;
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_device_group.html>
+#[derive(Clone)]
+pub struct DeviceGroup {
+    handle: vk::Device,
+    fp: vk::KhrDeviceGroupFn,
+}
+
+impl DeviceGroup {
+    /// # Warning
+    /// [`Instance`] functions cannot be loaded from a [`Device`] and will always panic when called:
+    /// - [`Self::get_physical_device_present_rectangles()`]
+    ///
+    /// Load this struct using an [`Instance`] instead via [`Self::new_from_instance()`] if the
+    /// above [`Instance`] function is called. This will be solved in the next breaking `ash`
+    /// release: <https://github.com/ash-rs/ash/issues/727>.
+    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 }
+    }
+
+    /// Loads all functions on the [`Instance`] instead of [`Device`]. This incurs an extra
+    /// dispatch table for [`Device`] functions but also allows the [`Instance`] function to be
+    /// loaded instead of always panicking. See also [`Self::new()`] for more details.
+    ///
+    /// It is okay to pass [`vk::Device::null()`] when this struct is only used to call the
+    /// [`Instance`] function.
+    pub fn new_from_instance(entry: &Entry, instance: &Instance, device: vk::Device) -> Self {
+        let fp = vk::KhrDeviceGroupFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { handle: device, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDeviceMaskKHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDispatchBaseKHR.html>
+    #[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].
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html>
+    ///
+    /// [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].
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html>
+    ///
+    /// [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<vk::DeviceGroupPresentModeFlagsKHR> {
+        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].
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html>
+    ///
+    /// [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
+    ///
+    /// # Warning
+    ///
+    /// Function will always panic unless this struct is loaded via [`Self::new_from_instance()`].
+    #[inline]
+    pub unsafe fn get_physical_device_present_rectangles(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<Vec<vk::Rect2D>> {
+        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].
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireNextImage2KHR.html>
+    ///
+    /// [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
+    }
+}

third-party/vendor/ash/src/extensions/khr/device_group_creation.rs

@@ -0,0 +1,72 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_device_group_creation.html>
+#[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<usize> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html>
+    ///
+    /// 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
+    }
+
+    #[deprecated = "typo: this function is called `device()`, but returns an `Instance`."]
+    #[inline]
+    pub fn device(&self) -> vk::Instance {
+        self.handle
+    }
+
+    #[inline]
+    pub fn instance(&self) -> vk::Instance {
+        self.handle
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_display_properties(
+        &self,
+        physical_device: vk::PhysicalDevice,
+    ) -> VkResult<Vec<vk::DisplayPropertiesKHR>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_physical_device_display_properties_khr)(physical_device, count, data)
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_display_plane_properties(
+        &self,
+        physical_device: vk::PhysicalDevice,
+    ) -> VkResult<Vec<vk::DisplayPlanePropertiesKHR>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_physical_device_display_plane_properties_khr)(physical_device, count, data)
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html>
+    #[inline]
+    pub unsafe fn get_display_plane_supported_displays(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        plane_index: u32,
+    ) -> VkResult<Vec<vk::DisplayKHR>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_display_plane_supported_displays_khr)(
+                physical_device,
+                plane_index,
+                count,
+                data,
+            )
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDisplayModePropertiesKHR.html>
+    #[inline]
+    pub unsafe fn get_display_mode_properties(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        display: vk::DisplayKHR,
+    ) -> VkResult<Vec<vk::DisplayModePropertiesKHR>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_display_mode_properties_khr)(physical_device, display, count, data)
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDisplayModeKHR.html>
+    #[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<vk::DisplayModeKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDisplayPlaneCapabilitiesKHR.html>
+    #[inline]
+    pub unsafe fn get_display_plane_capabilities(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        mode: vk::DisplayModeKHR,
+        plane_index: u32,
+    ) -> VkResult<vk::DisplayPlaneCapabilitiesKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDisplayPlaneSurfaceKHR.html>
+    #[inline]
+    pub unsafe fn create_display_plane_surface(
+        &self,
+        create_info: &vk::DisplaySurfaceCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateSharedSwapchainsKHR.html>
+    #[inline]
+    pub unsafe fn create_shared_swapchains(
+        &self,
+        create_infos: &[vk::SwapchainCreateInfoKHR],
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<Vec<vk::SwapchainKHR>> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndexedIndirectCountKHR.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndirectCountKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginRenderingKHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndRenderingKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportFenceFdKHR.html>
+    #[inline]
+    pub unsafe fn import_fence_fd(&self, import_info: &vk::ImportFenceFdInfoKHR) -> VkResult<()> {
+        (self.fp.import_fence_fd_khr)(self.handle, import_info).result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetFenceFdKHR.html>
+    #[inline]
+    pub unsafe fn get_fence_fd(&self, get_info: &vk::FenceGetFdInfoKHR) -> VkResult<i32> {
+        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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_fence_win32.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportFenceWin32HandleKHR.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetFenceWin32HandleKHR.html>
+    #[inline]
+    pub unsafe fn get_fence_win32_handle(
+        &self,
+        get_info: &vk::FenceGetWin32HandleInfoKHR,
+    ) -> VkResult<vk::HANDLE> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryFdKHR.html>
+    #[inline]
+    pub unsafe fn get_memory_fd(&self, get_fd_info: &vk::MemoryGetFdInfoKHR) -> VkResult<i32> {
+        let mut fd = -1;
+        (self.fp.get_memory_fd_khr)(self.handle, get_fd_info, &mut fd).result_with_success(fd)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryFdPropertiesKHR.html>
+    #[inline]
+    pub unsafe fn get_memory_fd_properties(
+        &self,
+        handle_type: vk::ExternalMemoryHandleTypeFlags,
+        fd: i32,
+    ) -> VkResult<vk::MemoryFdPropertiesKHR> {
+        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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_memory_win32.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryWin32HandleKHR.html>
+    #[inline]
+    pub unsafe fn get_memory_win32_handle(
+        &self,
+        create_info: &vk::MemoryGetWin32HandleInfoKHR,
+    ) -> VkResult<vk::HANDLE> {
+        let mut handle = ptr::null_mut();
+        (self.fp.get_memory_win32_handle_khr)(self.handle, create_info, &mut handle)
+            .result_with_success(handle)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryWin32HandlePropertiesKHR.html>
+    #[inline]
+    pub unsafe fn get_memory_win32_handle_properties(
+        &self,
+        handle_type: vk::ExternalMemoryHandleTypeFlags,
+        handle: vk::HANDLE,
+    ) -> VkResult<vk::MemoryWin32HandlePropertiesKHR> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportSemaphoreFdKHR.html>
+    #[inline]
+    pub unsafe fn import_semaphore_fd(
+        &self,
+        import_info: &vk::ImportSemaphoreFdInfoKHR,
+    ) -> VkResult<()> {
+        (self.fp.import_semaphore_fd_khr)(self.handle, import_info).result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSemaphoreFdKHR.html>
+    #[inline]
+    pub unsafe fn get_semaphore_fd(&self, get_info: &vk::SemaphoreGetFdInfoKHR) -> VkResult<i32> {
+        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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_semaphore_win32.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportSemaphoreWin32HandleKHR.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSemaphoreWin32HandleKHR.html>
+    #[inline]
+    pub unsafe fn get_semaphore_win32_handle(
+        &self,
+        get_info: &vk::SemaphoreGetWin32HandleInfoKHR,
+    ) -> VkResult<vk::HANDLE> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferMemoryRequirements2KHR.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageMemoryRequirements2KHR.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSparseMemoryRequirements2KHR.html>
+    ///
+    /// 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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFeatures2KHR.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceProperties2KHR.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html>
+    ///
+    /// 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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html>
+    ///
+    /// 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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_surface_capabilities2(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR,
+    ) -> VkResult<vk::SurfaceCapabilities2KHR> {
+        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<usize> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html>
+    ///
+    /// 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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkTrimCommandPoolKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorSetLayoutSupportKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html>
+    #[inline]
+    pub unsafe fn get_device_buffer_memory_requirements(
+        &self,
+        memory_requirements: &vk::DeviceBufferMemoryRequirementsKHR,
+        out: &mut vk::MemoryRequirements2,
+    ) {
+        (self.fp.get_device_buffer_memory_requirements_khr)(self.handle, memory_requirements, out)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceImageMemoryRequirementsKHR.html>
+    #[inline]
+    pub unsafe fn get_device_image_memory_requirements(
+        &self,
+        memory_requirements: &vk::DeviceImageMemoryRequirementsKHR,
+        out: &mut vk::MemoryRequirements2,
+    ) {
+        (self.fp.get_device_image_memory_requirements_khr)(self.handle, memory_requirements, 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,
+        memory_requirements: &vk::DeviceImageMemoryRequirementsKHR,
+    ) -> usize {
+        let mut count = 0;
+        (self.fp.get_device_image_sparse_memory_requirements_khr)(
+            self.handle,
+            memory_requirements,
+            &mut count,
+            std::ptr::null_mut(),
+        );
+        count as usize
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html>
+    ///
+    /// 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,
+        memory_requirements: &vk::DeviceImageMemoryRequirementsKHR,
+        out: &mut [vk::SparseImageMemoryRequirements2],
+    ) {
+        let mut count = out.len() as u32;
+        (self.fp.get_device_image_sparse_memory_requirements_khr)(
+            self.handle,
+            memory_requirements,
+            &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
+    }
+}

third-party/vendor/ash/src/extensions/khr/mod.rs

@@ -0,0 +1,77 @@
+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::performance_query::PerformanceQuery;
+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 performance_query;
+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;

third-party/vendor/ash/src/extensions/khr/performance_query.rs

@@ -0,0 +1,121 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_performance_query.html>
+#[derive(Clone)]
+pub struct PerformanceQuery {
+    handle: vk::Instance,
+    fp: vk::KhrPerformanceQueryFn,
+}
+
+impl PerformanceQuery {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrPerformanceQueryFn::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_queue_family_performance_query_counters()`][Self::enumerate_physical_device_queue_family_performance_query_counters()]
+    #[inline]
+    pub unsafe fn enumerate_physical_device_queue_family_performance_query_counters_len(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        queue_family_index: u32,
+    ) -> VkResult<usize> {
+        let mut count = 0;
+        (self
+            .fp
+            .enumerate_physical_device_queue_family_performance_query_counters_khr)(
+            physical_device,
+            queue_family_index,
+            &mut count,
+            ptr::null_mut(),
+            ptr::null_mut(),
+        )
+        .result_with_success(count as usize)
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html>
+    ///
+    /// Call [`enumerate_physical_device_queue_family_performance_query_counters_len()`][Self::enumerate_physical_device_queue_family_performance_query_counters_len()] to query the number of elements to pass to `out_counters` and `out_counter_descriptions`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn enumerate_physical_device_queue_family_performance_query_counters(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        queue_family_index: u32,
+        out_counters: &mut [vk::PerformanceCounterKHR],
+        out_counter_descriptions: &mut [vk::PerformanceCounterDescriptionKHR],
+    ) -> VkResult<()> {
+        assert_eq!(out_counters.len(), out_counter_descriptions.len());
+        let mut count = out_counters.len() as u32;
+        (self
+            .fp
+            .enumerate_physical_device_queue_family_performance_query_counters_khr)(
+            physical_device,
+            queue_family_index,
+            &mut count,
+            out_counters.as_mut_ptr(),
+            out_counter_descriptions.as_mut_ptr(),
+        )
+        .result()?;
+        assert_eq!(count as usize, out_counters.len());
+        assert_eq!(count as usize, out_counter_descriptions.len());
+        Ok(())
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_queue_family_performance_query_passes(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        performance_query_create_info: &vk::QueryPoolPerformanceCreateInfoKHR,
+    ) -> u32 {
+        let mut num_passes = 0;
+        (self
+            .fp
+            .get_physical_device_queue_family_performance_query_passes_khr)(
+            physical_device,
+            performance_query_create_info,
+            &mut num_passes,
+        );
+        num_passes
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkAcquireProfilingLockKHR.html>
+    #[inline]
+    pub unsafe fn acquire_profiling_lock(
+        &self,
+        device: vk::Device,
+        info: &vk::AcquireProfilingLockInfoKHR,
+    ) -> VkResult<()> {
+        (self.fp.acquire_profiling_lock_khr)(device, info).result()
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkReleaseProfilingLockKHR.html>
+    #[inline]
+    pub unsafe fn release_profiling_lock(&self, device: vk::Device) {
+        (self.fp.release_profiling_lock_khr)(device)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrPerformanceQueryFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrPerformanceQueryFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn instance(&self) -> vk::Instance {
+        self.handle
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html>
+    #[inline]
+    pub unsafe fn get_pipeline_executable_internal_representations(
+        &self,
+        executable_info: &vk::PipelineExecutableInfoKHR,
+    ) -> VkResult<Vec<vk::PipelineExecutableInternalRepresentationKHR>> {
+        read_into_defaulted_vector(|count, data| {
+            (self.fp.get_pipeline_executable_internal_representations_khr)(
+                self.handle,
+                executable_info,
+                count,
+                data,
+            )
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelineExecutablePropertiesKHR.html>
+    #[inline]
+    pub unsafe fn get_pipeline_executable_properties(
+        &self,
+        pipeline_info: &vk::PipelineInfoKHR,
+    ) -> VkResult<Vec<vk::PipelineExecutablePropertiesKHR>> {
+        read_into_defaulted_vector(|count, data| {
+            (self.fp.get_pipeline_executable_properties_khr)(
+                self.handle,
+                pipeline_info,
+                count,
+                data,
+            )
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelineExecutableStatisticsKHR.html>
+    #[inline]
+    pub unsafe fn get_pipeline_executable_statistics(
+        &self,
+        executable_info: &vk::PipelineExecutableInfoKHR,
+    ) -> VkResult<Vec<vk::PipelineExecutableStatisticKHR>> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkWaitForPresentKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPushDescriptorSetKHR.html>
+    #[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(),
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html>
+    #[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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_ray_tracing_maintenance1.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysIndirect2KHR.html>
+    ///
+    /// `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
+    }
+}

third-party/vendor/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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysKHR.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRayTracingPipelinesKHR.html>
+    #[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<Vec<vk::Pipeline>> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingShaderGroupHandlesKHR.html>
+    #[inline]
+    pub unsafe fn get_ray_tracing_shader_group_handles(
+        &self,
+        pipeline: vk::Pipeline,
+        first_group: u32,
+        group_count: u32,
+        data_size: usize,
+    ) -> VkResult<Vec<u8>> {
+        let mut data = Vec::<u8>::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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html>
+    #[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<Vec<u8>> {
+        let mut data = Vec::<u8>::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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysIndirectKHR.html>
+    ///
+    /// `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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html>
+    #[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,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_surface_support(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        queue_family_index: u32,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<bool> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_surface_present_modes(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<Vec<vk::PresentModeKHR>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_physical_device_surface_present_modes_khr)(
+                physical_device,
+                surface,
+                count,
+                data,
+            )
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_surface_capabilities(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<vk::SurfaceCapabilitiesKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_surface_formats(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<Vec<vk::SurfaceFormatKHR>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_physical_device_surface_formats_khr)(physical_device, surface, count, data)
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroySurfaceKHR.html>
+    #[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
+    }
+}

third-party/vendor/ash/src/extensions/khr/swapchain.rs

@@ -0,0 +1,236 @@
+#[cfg(doc)]
+use super::DeviceGroup;
+use crate::prelude::*;
+use crate::vk;
+use crate::RawPtr;
+use crate::{Device, Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html>
+#[derive(Clone)]
+pub struct Swapchain {
+    handle: vk::Device,
+    fp: vk::KhrSwapchainFn,
+}
+
+impl Swapchain {
+    /// # Warning
+    /// [`Instance`] functions cannot be loaded from a [`Device`] and will always panic when called:
+    /// - [`Self::get_physical_device_present_rectangles()`]
+    ///
+    /// Load this struct using an [`Instance`] instead via [`Self::new_from_instance()`] if the
+    /// above [`Instance`] function is called. This will be solved in the next breaking `ash`
+    /// release: <https://github.com/ash-rs/ash/issues/727>.
+    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 }
+    }
+
+    /// Loads all functions on the [`Instance`] instead of [`Device`]. This incurs an extra
+    /// dispatch table for [`Device`] functions but also allows the [`Instance`] function to be
+    /// loaded instead of always panicking. See also [`Self::new()`] for more details.
+    ///
+    /// It is okay to pass [`vk::Device::null()`] when this struct is only used to call the
+    /// [`Instance`] function.
+    pub fn new_from_instance(entry: &Entry, instance: &Instance, device: vk::Device) -> Self {
+        let fp = vk::KhrSwapchainFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { handle: device, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateSwapchainKHR.html>
+    #[inline]
+    pub unsafe fn create_swapchain(
+        &self,
+        create_info: &vk::SwapchainCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SwapchainKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroySwapchainKHR.html>
+    #[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());
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSwapchainImagesKHR.html>
+    #[inline]
+    pub unsafe fn get_swapchain_images(
+        &self,
+        swapchain: vk::SwapchainKHR,
+    ) -> VkResult<Vec<vk::Image>> {
+        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.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireNextImageKHR.html>
+    #[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.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueuePresentKHR.html>
+    #[inline]
+    pub unsafe fn queue_present(
+        &self,
+        queue: vk::Queue,
+        present_info: &vk::PresentInfoKHR,
+    ) -> VkResult<bool> {
+        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.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html>
+    ///
+    /// [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.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html>
+    ///
+    /// [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<vk::DeviceGroupPresentModeFlagsKHR> {
+        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.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html>
+    ///
+    /// [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
+    ///
+    /// # Warning
+    ///
+    /// Function will always panic unless this struct is loaded via [`Self::new_from_instance()`].
+    #[inline]
+    pub unsafe fn get_physical_device_present_rectangles(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<Vec<vk::Rect2D>> {
+        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.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireNextImage2KHR.html>
+    ///
+    /// [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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPipelineBarrier2KHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResetEvent2KHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetEvent2KHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWaitEvents2KHR.html>
+    #[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(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWriteTimestamp2KHR.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueSubmit2KHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSemaphoreCounterValue.html>
+    #[inline]
+    pub unsafe fn get_semaphore_counter_value(&self, semaphore: vk::Semaphore) -> VkResult<u64> {
+        let mut value = 0;
+        (self.fp.get_semaphore_counter_value_khr)(self.handle, semaphore, &mut value)
+            .result_with_success(value)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkWaitSemaphores.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSignalSemaphore.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateWaylandSurfaceKHR.html>
+    #[inline]
+    pub unsafe fn create_wayland_surface(
+        &self,
+        create_info: &vk::WaylandSurfaceCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateWin32SurfaceKHR.html>
+    #[inline]
+    pub unsafe fn create_win32_surface(
+        &self,
+        create_info: &vk::Win32SurfaceCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateXcbSurfaceKHR.html>
+    #[inline]
+    pub unsafe fn create_xcb_surface(
+        &self,
+        create_info: &vk::XcbSurfaceCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html>
+    #[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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateXlibSurfaceKHR.html>
+    #[inline]
+    pub unsafe fn create_xlib_surface(
+        &self,
+        create_info: &vk::XlibSurfaceCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html>
+    #[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
+    }
+}

third-party/vendor/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;

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateIOSSurfaceMVK.html>
+    #[inline]
+    pub unsafe fn create_ios_surface(
+        &self,
+        create_info: &vk::IOSSurfaceCreateInfoMVK,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateMacOSSurfaceMVK.html>
+    #[inline]
+    pub unsafe fn create_mac_os_surface(
+        &self,
+        create_info: &vk::MacOSSurfaceCreateInfoMVK,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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
+    }
+}

third-party/vendor/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;

third-party/vendor/ash/src/extensions/nn/mod.rs

@@ -0,0 +1,3 @@
+pub use self::vi_surface::ViSurface;
+
+mod vi_surface;

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateViSurfaceNN.html>
+    #[inline]
+    pub unsafe fn create_vi_surface(
+        &self,
+        create_info: &vk::ViSurfaceCreateInfoNN,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_NV_coverage_reduction_mode.html>
+#[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<usize> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html>
+    ///
+    /// 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
+    }
+}

third-party/vendor/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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_NV_device_diagnostic_checkpoints.html>
+#[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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCheckpointNV.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetQueueCheckpointDataNV.html>
+    ///
+    /// 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
+    }
+}

third-party/vendor/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 }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksNV.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectNV.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectCountNV.html>
+    #[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
+    }
+}

third-party/vendor/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;

third-party/vendor/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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateAccelerationStructureNV.html>
+    #[inline]
+    pub unsafe fn create_acceleration_structure(
+        &self,
+        create_info: &vk::AccelerationStructureCreateInfoNV,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::AccelerationStructureNV> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyAccelerationStructureNV.html>
+    #[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(),
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBindAccelerationStructureMemoryNV.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBuildAccelerationStructureNV.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyAccelerationStructureNV.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysNV.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRayTracingPipelinesNV.html>
+    #[inline]
+    pub unsafe fn create_ray_tracing_pipelines(
+        &self,
+        pipeline_cache: vk::PipelineCache,
+        create_info: &[vk::RayTracingPipelineCreateInfoNV],
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<Vec<vk::Pipeline>> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingShaderGroupHandlesNV.html>
+    #[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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureHandleNV.html>
+    #[inline]
+    pub unsafe fn get_acceleration_structure_handle(
+        &self,
+        accel_struct: vk::AccelerationStructureNV,
+    ) -> VkResult<u64> {
+        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::<u64>(),
+            handle_ptr.cast(),
+        )
+        .result_with_success(handle)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCompileDeferredNV.html>
+    #[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
+    }
+}

third-party/vendor/ash/src/instance.rs

@@ -0,0 +1,545 @@
+#[cfg(doc)]
+use super::Entry;
+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;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstance.html>
+#[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<usize> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceToolProperties.html>
+    ///
+    /// 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<usize> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumeratePhysicalDeviceGroups.html>
+    ///
+    /// 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(())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFeatures2.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceProperties2.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFormatProperties2.html>
+    #[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);
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html>
+    ///
+    /// 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());
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html>
+    ///
+    /// 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());
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceExternalBufferProperties.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceExternalFenceProperties.html>
+    #[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,
+        );
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDevice.html>
+    ///
+    /// # Safety
+    ///
+    /// There is a [parent/child relation] between [`Instance`] and the resulting [`Device`].  The
+    /// application must not [destroy][Instance::destroy_instance()] the parent [`Instance`] object
+    /// before first [destroying][Device::destroy_device()] the returned [`Device`] child object.
+    /// [`Device`] does _not_ implement [drop][drop()] semantics and can only be destroyed via
+    /// [`destroy_device()`][Device::destroy_device()].
+    ///
+    /// See the [`Entry::create_instance()`] documentation for more destruction ordering rules on
+    /// [`Instance`].
+    ///
+    /// [parent/child relation]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#fundamentals-objectmodel-lifetime
+    #[inline]
+    pub unsafe fn create_device(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        create_info: &vk::DeviceCreateInfo,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<Device> {
+        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))
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceProcAddr.html>
+    #[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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyInstance.html>
+    #[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());
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFormatProperties.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties.html>
+    #[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<vk::ImageFormatProperties> {
+        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)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceMemoryProperties.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceProperties.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html>
+    #[inline]
+    pub unsafe fn get_physical_device_queue_family_properties(
+        &self,
+        physical_device: vk::PhysicalDevice,
+    ) -> Vec<vk::QueueFamilyProperties> {
+        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()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFeatures.html>
+    #[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
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumeratePhysicalDevices.html>
+    #[inline]
+    pub unsafe fn enumerate_physical_devices(&self) -> VkResult<Vec<vk::PhysicalDevice>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.instance_fn_1_0.enumerate_physical_devices)(self.handle(), count, data)
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateDeviceExtensionProperties.html>
+    #[inline]
+    pub unsafe fn enumerate_device_extension_properties(
+        &self,
+        device: vk::PhysicalDevice,
+    ) -> VkResult<Vec<vk::ExtensionProperties>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.instance_fn_1_0.enumerate_device_extension_properties)(
+                device,
+                ptr::null(),
+                count,
+                data,
+            )
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateDeviceLayerProperties.html>
+    #[inline]
+    pub unsafe fn enumerate_device_layer_properties(
+        &self,
+        device: vk::PhysicalDevice,
+    ) -> VkResult<Vec<vk::LayerProperties>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.instance_fn_1_0.enumerate_device_layer_properties)(device, count, data)
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html>
+    #[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<vk::SparseImageFormatProperties> {
+        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()
+    }
+}

third-party/vendor/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
+//!
+//! <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/index.html>
+//!
+//! ## Examples
+//!
+//! ```no_run
+//! use ash::{vk, Entry};
+//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! 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<T> {
+    fn as_raw_ptr(&self) -> *const T;
+}
+
+impl<'r, T> RawPtr<T> 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<ash::vk::DeviceCreateFlags> = 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);
+    }
+}

third-party/vendor/ash/src/prelude.rs

@@ -0,0 +1,120 @@
+use std::convert::TryInto;
+#[cfg(feature = "debug")]
+use std::fmt;
+use std::mem;
+
+use crate::vk;
+pub type VkResult<T> = Result<T, vk::Result>;
+
+impl vk::Result {
+    #[inline]
+    pub fn result(self) -> VkResult<()> {
+        self.result_with_success(())
+    }
+
+    #[inline]
+    pub fn result_with_success<T>(self, v: T) -> VkResult<T> {
+        match self {
+            Self::SUCCESS => Ok(v),
+            _ => Err(self),
+        }
+    }
+
+    #[inline]
+    pub unsafe fn assume_init_on_success<T>(self, v: mem::MaybeUninit<T>) -> VkResult<T> {
+        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<N: Copy + Default + TryInto<usize>, T>(
+    f: impl Fn(&mut N, *mut T) -> vk::Result,
+) -> VkResult<Vec<T>>
+where
+    <N as TryInto<usize>>::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<usize>,
+    T: Default + Clone,
+>(
+    f: impl Fn(&mut N, *mut T) -> vk::Result,
+) -> VkResult<Vec<T>>
+where
+    <N as TryInto<usize>>::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<Value: Into<u64> + 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, "{accum:b}")?;
+    }
+    Ok(())
+}

third-party/vendor/ash/src/util.rs

@@ -0,0 +1,140 @@
+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<f32>]`
+/// 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<T> {
+    ptr: *mut c_void,
+    elem_size: vk::DeviceSize,
+    size: vk::DeviceSize,
+    _m: PhantomData<T>,
+}
+
+#[derive(Debug)]
+pub struct AlignIter<'a, T: 'a> {
+    align: &'a mut Align<T>,
+    current: vk::DeviceSize,
+}
+
+impl<T: Copy> Align<T> {
+    pub fn copy_from_slice(&mut self, slice: &[T]) {
+        use std::slice::from_raw_parts_mut;
+        if self.elem_size == size_of::<T>() 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<T> Align<T> {
+    pub unsafe fn new(ptr: *mut c_void, alignment: vk::DeviceSize, size: vk::DeviceSize) -> Self {
+        let padding = calc_padding(size_of::<T>() as vk::DeviceSize, alignment);
+        let elem_size = size_of::<T>() 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<T> {
+        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<Self::Item> {
+        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::<u8>())
+                .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<R: io::Read + io::Seek>(x: &mut R) -> io::Result<Vec<u32>> {
+    // TODO use stream_len() once it is stabilized and remove the subsequent rewind() call
+    let size = x.seek(io::SeekFrom::End(0))?;
+    x.rewind()?;
+    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.read_exact(unsafe {
+        slice::from_raw_parts_mut(result.as_mut_ptr().cast::<u8>(), 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)
+}

third-party/vendor/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<T>(ptr: &mut T) -> impl Iterator<Item = *mut BaseOutStructure> {
+    let ptr = <*mut T>::cast::<BaseOutStructure>(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;
+}

third-party/vendor/ash/src/vk/aliases.rs

@@ -0,0 +1,253 @@
+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 ShaderRequiredSubgroupSizeCreateInfoEXT =
+    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;

third-party/vendor/ash/src/vk/constants.rs

@@ -0,0 +1,28 @@
+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 REMAINING_3D_SLICES_EXT: 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;

third-party/vendor/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);
+}

third-party/vendor/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)
+            }
+        }
+    };
+}

third-party/vendor/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;